@kubb/agent 5.0.0-alpha.16 → 5.0.0-alpha.18

package/.output/server/chunks/nitro/nitro.mjs

@@ -4456,73 +4456,12 @@ const logger = {
 const _KZ9YuROWp70nNn4X1C4BxF_W0D7H9EWgBo03XvMd7w0 = defineNitroPlugin(() => {
 });
 
-var __typeError$d = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck$d = (obj, member, msg) => member.has(obj) || __typeError$d("Cannot " + msg);
-var __privateGet$d = (obj, member, getter) => (__accessCheck$d(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd$d = (obj, member, value) => member.has(obj) ? __typeError$d("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var _emitter$1, _a$d;
-function toError$1(value) {
-  return value instanceof Error ? value : new Error(String(value));
-}
-var AsyncEventEmitter$1 = (_a$d = class {
-  /**
-  * `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
-  * @default 10
-  */
-  constructor(maxListener = 10) {
-    __privateAdd$d(this, _emitter$1, new EventEmitter());
-    __privateGet$d(this, _emitter$1).setMaxListeners(maxListener);
-  }
-  /**
-  * Emits an event and awaits all registered listeners in parallel.
-  * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-  */
-  async emit(eventName, ...eventArgs) {
-    const listeners = __privateGet$d(this, _emitter$1).listeners(eventName);
-    if (listeners.length === 0) return;
-    await Promise.all(listeners.map(async (listener) => {
-      try {
-        return await listener(...eventArgs);
-      } catch (err) {
-        let serializedArgs;
-        try {
-          serializedArgs = JSON.stringify(eventArgs);
-        } catch {
-          serializedArgs = String(eventArgs);
-        }
-        throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError$1(err) });
-      }
-    }));
-  }
-  /** Registers a persistent listener for the given event. */
-  on(eventName, handler) {
-    __privateGet$d(this, _emitter$1).on(eventName, handler);
-  }
-  /** Registers a one-shot listener that removes itself after the first invocation. */
-  onOnce(eventName, handler) {
-    const wrapper = (...args) => {
-      this.off(eventName, wrapper);
-      return handler(...args);
-    };
-    this.on(eventName, wrapper);
-  }
-  /** Removes a previously registered listener. */
-  off(eventName, handler) {
-    __privateGet$d(this, _emitter$1).off(eventName, handler);
-  }
-  /** Removes all listeners from every event channel. */
-  removeAll() {
-    __privateGet$d(this, _emitter$1).removeAllListeners();
-  }
-}, _emitter$1 = new WeakMap(), _a$d);
 function formatMs$1(ms) {
   if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
   if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
   return `${Math.round(ms)}ms`;
 }
-function parseHex$2(color) {
+function parseHex(color) {
   const int = Number.parseInt(color.replace("#", ""), 16);
   return Number.isNaN(int) ? {
     r: 255,
@@ -4534,18 +4473,18 @@ function parseHex$2(color) {
     b: int & 255
   };
 }
-function hex$2(color) {
-  const { r, g, b } = parseHex$2(color);
+function hex(color) {
+  const { r, g, b } = parseHex(color);
   return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
 }
 ({
-  lid: hex$2("#F55A17"),
-  woodTop: hex$2("#F5A217"),
-  woodMid: hex$2("#F58517"),
-  woodBase: hex$2("#B45309"),
-  eye: hex$2("#FFFFFF"),
-  highlight: hex$2("#adadc6"),
-  blush: hex$2("#FDA4AF")
+  lid: hex("#F55A17"),
+  woodTop: hex("#F5A217"),
+  woodMid: hex("#F58517"),
+  woodBase: hex("#B45309"),
+  eye: hex("#FFFFFF"),
+  highlight: hex("#adadc6"),
+  blush: hex("#FDA4AF")
 });
 function maskString(value, start = 8, end = 4) {
   if (value.length <= start + end) return value;
@@ -4654,6 +4593,75 @@ async function disconnect({ sessionId, token, studioUrl }) {
 const visitorDepths = {
   deep: "deep"
 };
+const schemaTypes = {
+  enum: "enum"};
+function toCamelOrPascal$f(text, pascal) {
+  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+    if (word.length > 1 && word === word.toUpperCase()) return word;
+    if (i === 0 && true) return word.charAt(0).toLowerCase() + word.slice(1);
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+function applyToFileParts$f(text, transformPart) {
+  const parts = text.split(/\.(?=[a-zA-Z])/);
+  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+function camelCase$f(text, { isFile, prefix = "", suffix = "" } = {}) {
+  if (isFile) return applyToFileParts$f(text, (part, isLast) => camelCase$f(part, isLast ? {
+    prefix,
+    suffix
+  } : {}));
+  return toCamelOrPascal$f(`${prefix} ${text} ${suffix}`);
+}
+function isValidVarName$c(name) {
+  try {
+    new Function(`var ${name}`);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function narrowSchema(node, type) {
+  return (node == null ? void 0 : node.type) === type ? node : void 0;
+}
+function isKind(kind) {
+  return (node) => node.kind === kind;
+}
+const isOperationNode = isKind("Operation");
+const isSchemaNode = isKind("Schema");
+const plainStringTypes = /* @__PURE__ */ new Set([
+  "string",
+  "uuid",
+  "email",
+  "url",
+  "datetime"
+]);
+function isStringType(node) {
+  var _a;
+  if (plainStringTypes.has(node.type)) return true;
+  const temporal = (_a = narrowSchema(node, "date")) != null ? _a : narrowSchema(node, "time");
+  if (temporal) return temporal.representation !== "date";
+  return false;
+}
+function caseParams(params, casing) {
+  if (!casing) return params;
+  return params.map((param) => {
+    const transformed = casing === "camelcase" || !isValidVarName$c(param.name) ? camelCase$f(param.name) : param.name;
+    return {
+      ...param,
+      name: transformed
+    };
+  });
+}
+function syncOptionality(required, schema) {
+  var _a;
+  const nullable = (_a = schema.nullable) != null ? _a : false;
+  return {
+    ...schema,
+    optional: !required && !nullable ? true : void 0,
+    nullish: !required && nullable ? true : void 0
+  };
+}
 function createSchema(props) {
   if (props["type"] === "object") return {
     properties: [],
@@ -4665,15 +4673,6 @@ function createSchema(props) {
     kind: "Schema"
   };
 }
-function syncPropertySchema(required, schema) {
-  var _a;
-  const nullable = (_a = schema.nullable) != null ? _a : false;
-  return {
-    ...schema,
-    optional: !required && !nullable ? true : void 0,
-    nullish: !required && nullable ? true : void 0
-  };
-}
 function createProperty(props) {
   var _a;
   const required = (_a = props.required) != null ? _a : false;
@@ -4681,7 +4680,7 @@ function createProperty(props) {
     ...props,
     kind: "Property",
     required,
-    schema: syncPropertySchema(required, props.schema)
+    schema: syncOptionality(required, props.schema)
   };
 }
 function createParameter(props) {
@@ -4691,7 +4690,7 @@ function createParameter(props) {
     ...props,
     kind: "Parameter",
     required,
-    schema: syncPropertySchema(required, props.schema)
+    schema: syncOptionality(required, props.schema)
   };
 }
 function definePrinter(build) {
@@ -4705,9 +4704,9 @@ function createPrinterFactory(getKey) {
         options: resolvedOptions,
         print: (node) => {
           const key = getKey(node);
-          if (key === void 0) return void 0;
+          if (key === void 0) return null;
           const handler = nodes[key];
-          if (!handler) return void 0;
+          if (!handler) return null;
           return handler.call(context, node);
         }
       };
@@ -4719,81 +4718,6 @@ function createPrinterFactory(getKey) {
     };
   };
 }
-function narrowSchema(node, type) {
-  return (node == null ? void 0 : node.type) === type ? node : void 0;
-}
-function isKind(kind) {
-  return (node) => node.kind === kind;
-}
-const isOperationNode = isKind("Operation");
-const isSchemaNode = isKind("Schema");
-function toCamelOrPascal$f(text, pascal) {
-  return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-    if (word.length > 1 && word === word.toUpperCase()) return word;
-    if (i === 0 && true) return word.charAt(0).toLowerCase() + word.slice(1);
-    return word.charAt(0).toUpperCase() + word.slice(1);
-  }).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-function applyToFileParts$f(text, transformPart) {
-  const parts = text.split(/\.(?=[a-zA-Z])/);
-  return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-function camelCase$f(text, { isFile, prefix = "", suffix = "" } = {}) {
-  if (isFile) return applyToFileParts$f(text, (part, isLast) => camelCase$f(part, isLast ? {
-    prefix,
-    suffix
-  } : {}));
-  return toCamelOrPascal$f(`${prefix} ${text} ${suffix}`);
-}
-function parseHex$1(color) {
-  const int = Number.parseInt(color.replace("#", ""), 16);
-  return Number.isNaN(int) ? {
-    r: 255,
-    g: 255,
-    b: 255
-  } : {
-    r: int >> 16 & 255,
-    g: int >> 8 & 255,
-    b: int & 255
-  };
-}
-function hex$1(color) {
-  const { r, g, b } = parseHex$1(color);
-  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
-}
-hex$1("#F55A17"), hex$1("#F5A217"), hex$1("#F58517"), hex$1("#B45309"), hex$1("#FFFFFF"), hex$1("#adadc6"), hex$1("#FDA4AF");
-function isValidVarName$c(name) {
-  try {
-    new Function(`var ${name}`);
-  } catch {
-    return false;
-  }
-  return true;
-}
-const plainStringTypes = /* @__PURE__ */ new Set([
-  "string",
-  "uuid",
-  "email",
-  "url",
-  "datetime"
-]);
-function isPlainStringType(node) {
-  var _a;
-  if (plainStringTypes.has(node.type)) return true;
-  const temporal = (_a = narrowSchema(node, "date")) != null ? _a : narrowSchema(node, "time");
-  if (temporal) return temporal.representation !== "date";
-  return false;
-}
-function applyParamsCasing$1(params, casing) {
-  if (!casing) return params;
-  return params.map((param) => {
-    const transformed = casing === "camelcase" || !isValidVarName$c(param.name) ? camelCase$f(param.name) : param.name;
-    return {
-      ...param,
-      name: transformed
-    };
-  });
-}
 function createLimit(concurrency) {
   let active = 0;
   const queue = [];
@@ -5096,7 +5020,7 @@ function toError(value) {
 }
 var AsyncEventEmitter = (_a$c = class {
   /**
-  * `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+  * Maximum number of listeners per event before Node emits a memory-leak warning.
   * @default 10
   */
   constructor(maxListener = 10) {
@@ -5104,8 +5028,13 @@ var AsyncEventEmitter = (_a$c = class {
     __privateGet$c(this, _emitter).setMaxListeners(maxListener);
   }
   /**
-  * Emits an event and awaits all registered listeners in parallel.
+  * Emits `eventName` and awaits all registered listeners in parallel.
   * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+  *
+  * @example
+  * ```ts
+  * await emitter.emit('build', 'petstore')
+  * ```
   */
   async emit(eventName, ...eventArgs) {
     const listeners = __privateGet$c(this, _emitter).listeners(eventName);
@@ -5124,11 +5053,25 @@ var AsyncEventEmitter = (_a$c = class {
       }
     }));
   }
-  /** Registers a persistent listener for the given event. */
+  /**
+  * Registers a persistent listener for `eventName`.
+  *
+  * @example
+  * ```ts
+  * emitter.on('build', async (name) => { console.log(name) })
+  * ```
+  */
   on(eventName, handler) {
     __privateGet$c(this, _emitter).on(eventName, handler);
   }
-  /** Registers a one-shot listener that removes itself after the first invocation. */
+  /**
+  * Registers a one-shot listener that removes itself after the first invocation.
+  *
+  * @example
+  * ```ts
+  * emitter.onOnce('build', async (name) => { console.log(name) })
+  * ```
+  */
   onOnce(eventName, handler) {
     const wrapper = (...args) => {
       this.off(eventName, wrapper);
@@ -5136,11 +5079,25 @@ var AsyncEventEmitter = (_a$c = class {
     };
     this.on(eventName, wrapper);
   }
-  /** Removes a previously registered listener. */
+  /**
+  * Removes a previously registered listener.
+  *
+  * @example
+  * ```ts
+  * emitter.off('build', handler)
+  * ```
+  */
   off(eventName, handler) {
     __privateGet$c(this, _emitter).off(eventName, handler);
   }
-  /** Removes all listeners from every event channel. */
+  /**
+  * Removes all listeners from every event channel.
+  *
+  * @example
+  * ```ts
+  * emitter.removeAll()
+  * ```
+  */
   removeAll() {
     __privateGet$c(this, _emitter).removeAllListeners();
   }
@@ -5180,23 +5137,6 @@ function formatMs(ms) {
   if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
   return `${Math.round(ms)}ms`;
 }
-function parseHex(color) {
-  const int = Number.parseInt(color.replace("#", ""), 16);
-  return Number.isNaN(int) ? {
-    r: 255,
-    g: 255,
-    b: 255
-  } : {
-    r: int >> 16 & 255,
-    g: int >> 8 & 255,
-    b: int & 255
-  };
-}
-function hex(color) {
-  const { r, g, b } = parseHex(color);
-  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[0m`;
-}
-hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
 function toSlash(p) {
   if (p.startsWith("\\\\?\\")) return p;
   return p.replaceAll("\\", "/");
@@ -5215,16 +5155,16 @@ function readSync(path2) {
 }
 async function write(path2, data, options = {}) {
   const trimmed = data.trim();
-  if (trimmed === "") return void 0;
+  if (trimmed === "") return null;
   const resolved = resolve(path2);
   if (typeof Bun !== "undefined") {
     const file = Bun.file(resolved);
-    if ((await file.exists() ? await file.text() : null) === trimmed) return void 0;
+    if ((await file.exists() ? await file.text() : null) === trimmed) return null;
     await Bun.write(resolved, trimmed);
     return trimmed;
   }
   try {
-    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+    if (await readFile$1(resolved, { encoding: "utf-8" }) === trimmed) return null;
   } catch {
   }
   await mkdir(dirname(resolved), { recursive: true });
@@ -5360,17 +5300,32 @@ function isValidVarName$b(name) {
 var URLPath$a = (_b$2 = class {
   constructor(path2, options = {}) {
     __privateAdd$c(this, _URLPath_instances$a);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$b(this, "path");
     __privateAdd$c(this, _options$c);
     this.path = path2;
     __privateSet$c(this, _options$c, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -5388,11 +5343,25 @@ var URLPath$a = (_b$2 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -5426,6 +5395,12 @@ var URLPath$a = (_b$2 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -5435,14 +5410,22 @@ var URLPath$a = (_b$2 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$c = new WeakMap(), _URLPath_instances$a = new WeakSet(), transformParam_fn$a = function(raw) {
   const param = isValidVarName$b(raw) ? raw : camelCase$e(raw);
   return __privateGet$c(this, _options$c).casing === "camelcase" ? camelCase$e(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$a = function(fn) {
   for (const match2 of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match2[1];
@@ -6124,7 +6107,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.16";
+var version$1 = "5.0.0-alpha.18";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6682,6 +6665,7 @@ async function detectFormatter() {
     "prettier"
   ]);
   for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
+  return null;
 }
 var TreeNode = (_f = class {
   constructor(data, parent) {
@@ -6698,10 +6682,18 @@ var TreeNode = (_f = class {
     this.children.push(child);
     return child;
   }
+  /**
+  * Returns the root ancestor of this node, walking up via `parent` links.
+  */
   get root() {
     if (!this.parent) return this;
     return this.parent.root;
   }
+  /**
+  * Returns all leaf descendants (nodes with no children) of this node.
+  *
+  * Results are cached after the first traversal.
+  */
   get leaves() {
     if (!this.children || this.children.length === 0) return [this];
     if (__privateGet$c(this, _cachedLeaves)) return __privateGet$c(this, _cachedLeaves);
@@ -6732,6 +6724,12 @@ var TreeNode = (_f = class {
     if (typeof callback !== "function") throw new TypeError("map() callback must be a function");
     return this.leaves.map(callback);
   }
+  /**
+  * Builds a {@link TreeNode} tree from a flat list of files.
+  *
+  * - Filters to files under `root` (when provided) and skips `.json` files.
+  * - Returns `null` when no files match.
+  */
   static build(files, root) {
     var _a2;
     try {
@@ -6912,24 +6910,26 @@ async function detectLinter() {
     "eslint"
   ]);
   for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
+  return null;
 }
 function getPackageJSONSync(cwd) {
   const pkgPath = pkg.up({ cwd });
-  if (!pkgPath) return;
+  if (!pkgPath) return null;
   return JSON.parse(readSync(pkgPath));
 }
 function match(packageJSON, dependency) {
+  var _a2;
   const dependencies = {
     ...packageJSON.dependencies || {},
     ...packageJSON.devDependencies || {}
   };
   if (dependencies[dependency]) return dependencies[dependency];
   const matched = Object.keys(dependencies).find((dep) => dep.match(dependency));
-  return matched ? dependencies[matched] : void 0;
+  return matched ? (_a2 = dependencies[matched]) != null ? _a2 : null : null;
 }
 function getVersionSync(dependency, cwd) {
   const packageJSON = getPackageJSONSync(cwd);
-  return packageJSON ? match(packageJSON, dependency) : void 0;
+  return packageJSON ? match(packageJSON, dependency) : null;
 }
 function satisfiesDependency(dependency, version2, cwd) {
   const packageVersion = getVersionSync(dependency, cwd);
@@ -6940,7 +6940,7 @@ function satisfiesDependency(dependency, version2, cwd) {
   return satisfies(semVer, version2);
 }
 
-var version = "5.0.0-alpha.16";
+var version = "5.0.0-alpha.18";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7323,17 +7323,32 @@ function isValidVarName$a(name) {
 var URLPath$9 = (_a$b = class {
   constructor(path2, options = {}) {
     __privateAdd$b(this, _URLPath_instances$9);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$a(this, "path");
     __privateAdd$b(this, _options$b);
     this.path = path2;
     __privateSet$b(this, _options$b, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -7351,11 +7366,25 @@ var URLPath$9 = (_a$b = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -7389,6 +7418,12 @@ var URLPath$9 = (_a$b = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -7398,14 +7433,22 @@ var URLPath$9 = (_a$b = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$b = new WeakMap(), _URLPath_instances$9 = new WeakSet(), transformParam_fn$9 = function(raw) {
   const param = isValidVarName$a(raw) ? raw : camelCase$c(raw);
   return __privateGet$b(this, _options$b).casing === "camelcase" ? camelCase$c(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$9 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -9228,17 +9271,32 @@ function isValidVarName$9(name) {
 var URLPath$8 = (_a$9 = class {
   constructor(path, options = {}) {
     __privateAdd$9(this, _URLPath_instances$8);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$8(this, "path");
     __privateAdd$9(this, _options$9);
     this.path = path;
     __privateSet$9(this, _options$9, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -9256,11 +9314,25 @@ var URLPath$8 = (_a$9 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -9294,6 +9366,12 @@ var URLPath$8 = (_a$9 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -9303,14 +9381,22 @@ var URLPath$8 = (_a$9 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$9 = new WeakMap(), _URLPath_instances$8 = new WeakSet(), transformParam_fn$8 = function(raw) {
   const param = isValidVarName$9(raw) ? raw : camelCase$d(raw);
   return __privateGet$9(this, _options$9).casing === "camelcase" ? camelCase$d(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$8 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -9467,17 +9553,32 @@ function isValidVarName$8(name) {
 var URLPath$7 = (_a$8 = class {
   constructor(path, options = {}) {
     __privateAdd$8(this, _URLPath_instances$7);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$7(this, "path");
     __privateAdd$8(this, _options$8);
     this.path = path;
     __privateSet$8(this, _options$8, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -9495,11 +9596,25 @@ var URLPath$7 = (_a$8 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -9533,6 +9648,12 @@ var URLPath$7 = (_a$8 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -9542,14 +9663,22 @@ var URLPath$7 = (_a$8 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$8 = new WeakMap(), _URLPath_instances$7 = new WeakSet(), transformParam_fn$7 = function(raw) {
   const param = isValidVarName$8(raw) ? raw : camelCase$b(raw);
   return __privateGet$8(this, _options$8).casing === "camelcase" ? camelCase$b(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$7 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -209510,12 +209639,15 @@ const printerTs = definePrinter((options) => {
       union(node) {
         var _a, _b, _c;
         const members = (_a = node.members) != null ? _a : [];
-        const hasStringLiteral = members.some((m) => m.type === "enum" && (m.enumType === "string" || m.primitive === "string"));
-        const hasPlainString = members.some((m) => isPlainStringType(m));
+        const hasStringLiteral = members.some((m) => {
+          var _a2;
+          return ((_a2 = narrowSchema(m, schemaTypes.enum)) == null ? void 0 : _a2.primitive) === "string";
+        });
+        const hasPlainString = members.some((m) => isStringType(m));
         if (hasStringLiteral && hasPlainString) return (_b = createUnionDeclaration({
           withParentheses: true,
           nodes: members.map((m) => {
-            if (isPlainStringType(m)) return createIntersectionDeclaration({
+            if (isStringType(m)) return createIntersectionDeclaration({
               nodes: [keywordTypeNodes.string, createTypeLiteralNode([])],
               withParentheses: true
             });
@@ -209647,7 +209779,8 @@ function Enum({ node, enumType, enumKeyCasing, resolver }) {
 function Type({ name, typedName, node, keysToOmit, optionalType, arrayType, syntaxType, enumType, enumKeyCasing, description, resolver }) {
   const resolvedDescription = description || (node == null ? void 0 : node.description);
   const enumSchemaNodes = collect(node, { schema(n) {
-    if (n.type === "enum" && n.name) return n;
+    const enumNode = narrowSchema(n, schemaTypes.enum);
+    if (enumNode == null ? void 0 : enumNode.name) return enumNode;
   } });
   const typeNode = printerTs({
     optionalType,
@@ -209987,8 +210120,9 @@ function buildLegacyResponseUnionSchemaNode({ node, resolver }) {
 function nameUnnamedEnums(node, parentName) {
   return transform(node, {
     schema(n) {
-      if (n.type === "enum" && !n.name) return {
-        ...n,
+      const enumNode = narrowSchema(n, "enum");
+      if (enumNode && !enumNode.name) return {
+        ...enumNode,
         name: pascalCase$6([parentName, "enum"].join(" "))
       };
     },
@@ -210022,7 +210156,7 @@ const typeGenerator = defineGenerator({
       mode,
       options: { group: group ? group.type === "tag" ? { tag: (_a = node.tags[0]) != null ? _a : "default" } : { path: node.path } : void 0 }
     });
-    const params = applyParamsCasing$1(node.parameters, paramsCasing);
+    const params = caseParams(node.parameters, paramsCasing);
     function renderSchemaType({ node: schemaNode, name, typedName, description, keysToOmit }) {
       if (!schemaNode) return null;
       const transformedNode = transform(schemaNode, composeTransformers(...transformers));
@@ -210217,7 +210351,7 @@ const typeGenerator = defineGenerator({
         mode
       }).path
     }));
-    const isEnumSchema = node.type === "enum";
+    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum);
     const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name);
     const type = {
       name: resolver.resolveName(node.name),
@@ -211963,17 +212097,32 @@ function isValidVarName$7(name) {
 var URLPath$6 = (_a$6 = class {
   constructor(path, options = {}) {
     __privateAdd$6(this, _URLPath_instances$6);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$6(this, "path");
     __privateAdd$6(this, _options$6);
     this.path = path;
     __privateSet$6(this, _options$6, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -211991,11 +212140,25 @@ var URLPath$6 = (_a$6 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -212029,6 +212192,12 @@ var URLPath$6 = (_a$6 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -212038,14 +212207,22 @@ var URLPath$6 = (_a$6 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$6 = new WeakMap(), _URLPath_instances$6 = new WeakSet(), transformParam_fn$6 = function(raw) {
   const param = isValidVarName$7(raw) ? raw : camelCase$8(raw);
   return __privateGet$6(this, _options$6).casing === "camelcase" ? camelCase$8(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$6 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -213498,17 +213675,32 @@ function isValidVarName$5(name) {
 var URLPath$5 = (_a$5 = class {
   constructor(path, options = {}) {
     __privateAdd$5(this, _URLPath_instances$5);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$5(this, "path");
     __privateAdd$5(this, _options$5);
     this.path = path;
     __privateSet$5(this, _options$5, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -213526,11 +213718,25 @@ var URLPath$5 = (_a$5 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -213564,6 +213770,12 @@ var URLPath$5 = (_a$5 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -213573,14 +213785,22 @@ var URLPath$5 = (_a$5 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$5 = new WeakMap(), _URLPath_instances$5 = new WeakSet(), transformParam_fn$5 = function(raw) {
   const param = isValidVarName$5(raw) ? raw : camelCase$5(raw);
   return __privateGet$5(this, _options$5).casing === "camelcase" ? camelCase$5(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$5 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -213960,7 +214180,7 @@ function pascalCase$4(text, { isFile, prefix = "", suffix = "" } = {}) {
 }
 function getNestedAccessor$1(param, accessor) {
   const parts = Array.isArray(param) ? param : param.split(".");
-  if (parts.length === 0 || parts.length === 1 && parts[0] === "") return void 0;
+  if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
   return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 function isValidVarName$4(name) {
@@ -213974,17 +214194,32 @@ function isValidVarName$4(name) {
 var URLPath$4 = (_a$4 = class {
   constructor(path, options = {}) {
     __privateAdd$4(this, _URLPath_instances$4);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$4(this, "path");
     __privateAdd$4(this, _options$4);
     this.path = path;
     __privateSet$4(this, _options$4, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -214002,11 +214237,25 @@ var URLPath$4 = (_a$4 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -214040,6 +214289,12 @@ var URLPath$4 = (_a$4 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -214049,14 +214304,22 @@ var URLPath$4 = (_a$4 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$4 = new WeakMap(), _URLPath_instances$4 = new WeakSet(), transformParam_fn$4 = function(raw) {
   const param = isValidVarName$4(raw) ? raw : camelCase$4(raw);
   return __privateGet$4(this, _options$4).casing === "camelcase" ? camelCase$4(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$4 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -217044,17 +217307,32 @@ function isValidVarName$3(name) {
 var URLPath$3 = (_a$3 = class {
   constructor(path, options = {}) {
     __privateAdd$3(this, _URLPath_instances$3);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$3(this, "path");
     __privateAdd$3(this, _options$3);
     this.path = path;
     __privateSet$3(this, _options$3, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -217072,11 +217350,25 @@ var URLPath$3 = (_a$3 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -217110,6 +217402,12 @@ var URLPath$3 = (_a$3 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -217119,14 +217417,22 @@ var URLPath$3 = (_a$3 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$3 = new WeakMap(), _URLPath_instances$3 = new WeakSet(), transformParam_fn$3 = function(raw) {
   const param = isValidVarName$3(raw) ? raw : camelCase$3(raw);
   return __privateGet$3(this, _options$3).casing === "camelcase" ? camelCase$3(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$3 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -218194,17 +218500,32 @@ function isValidVarName$2(name) {
 var URLPath$2 = (_a$2 = class {
   constructor(path, options = {}) {
     __privateAdd$2(this, _URLPath_instances$2);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$2(this, "path");
     __privateAdd$2(this, _options$2);
     this.path = path;
     __privateSet$2(this, _options$2, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -218222,11 +218543,25 @@ var URLPath$2 = (_a$2 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -218260,6 +218595,12 @@ var URLPath$2 = (_a$2 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -218269,14 +218610,22 @@ var URLPath$2 = (_a$2 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$2 = new WeakMap(), _URLPath_instances$2 = new WeakSet(), transformParam_fn$2 = function(raw) {
   const param = isValidVarName$2(raw) ? raw : camelCase$2(raw);
   return __privateGet$2(this, _options$2).casing === "camelcase" ? camelCase$2(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$2 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -219344,17 +219693,32 @@ function isValidVarName$1(name) {
 var URLPath$1 = (_a$1 = class {
   constructor(path, options = {}) {
     __privateAdd$1(this, _URLPath_instances$1);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField$1(this, "path");
     __privateAdd$1(this, _options$1);
     this.path = path;
     __privateSet$1(this, _options$1, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -219372,11 +219736,25 @@ var URLPath$1 = (_a$1 = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -219410,6 +219788,12 @@ var URLPath$1 = (_a$1 = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -219419,14 +219803,22 @@ var URLPath$1 = (_a$1 = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options$1 = new WeakMap(), _URLPath_instances$1 = new WeakSet(), transformParam_fn$1 = function(raw) {
   const param = isValidVarName$1(raw) ? raw : camelCase$1(raw);
   return __privateGet$1(this, _options$1).casing === "camelcase" ? camelCase$1(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn$1 = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -220507,7 +220899,7 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 }
 function getNestedAccessor(param, accessor) {
   const parts = Array.isArray(param) ? param : param.split(".");
-  if (parts.length === 0 || parts.length === 1 && parts[0] === "") return void 0;
+  if (parts.length === 0 || parts.length === 1 && parts[0] === "") return null;
   return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 function isValidVarName(name) {
@@ -220521,17 +220913,32 @@ function isValidVarName(name) {
 var URLPath = (_a = class {
   constructor(path, options = {}) {
     __privateAdd(this, _URLPath_instances);
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+    /**
+    * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+    */
     __publicField(this, "path");
     __privateAdd(this, _options);
     this.path = path;
     __privateSet(this, _options, options);
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+  * ```
+  */
   get URL() {
     return this.toURLPath();
   }
-  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+  *
+  * @example
+  * ```ts
+  * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+  * new URLPath('/pet/{petId}').isURL                       // false
+  * ```
+  */
   get isURL() {
     try {
       return !!new URL(this.path).href;
@@ -220549,11 +220956,25 @@ var URLPath = (_a = class {
   get template() {
     return this.toTemplateString();
   }
-  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').object
+  * // { url: '/pet/:petId', params: { petId: 'petId' } }
+  * ```
+  */
   get object() {
     return this.toObject();
   }
-  /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+  * new URLPath('/pet').params         // undefined
+  * ```
+  */
   get params() {
     return this.getParams();
   }
@@ -220587,6 +221008,12 @@ var URLPath = (_a = class {
   * Extracts all `{param}` segments from the path and returns them as a key-value map.
   * An optional `replacer` transforms each parameter name in both key and value positions.
   * Returns `undefined` when no path parameters are found.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+  * // { petId: 'petId', tagId: 'tagId' }
+  * ```
   */
   getParams(replacer) {
     const params = {};
@@ -220596,14 +221023,22 @@ var URLPath = (_a = class {
     });
     return Object.keys(params).length > 0 ? params : void 0;
   }
-  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+  /** Converts the OpenAPI path to Express-style colon syntax.
+  *
+  * @example
+  * ```ts
+  * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+  * ```
+  */
   toURLPath() {
     return this.path.replace(/\{([^}]+)\}/g, ":$1");
   }
 }, _options = new WeakMap(), _URLPath_instances = new WeakSet(), transformParam_fn = function(raw) {
   const param = isValidVarName(raw) ? raw : camelCase(raw);
   return __privateGet(this, _options).casing === "camelcase" ? camelCase(param) : param;
-}, /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+}, /**
+* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+*/
 eachParam_fn = function(fn) {
   for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
     const raw = match[1];
@@ -222478,7 +222913,7 @@ async function connectToStudio(options) {
     initialSession,
     nitro
   } = options;
-  const events = new AsyncEventEmitter$1();
+  const events = new AsyncEventEmitter();
   let currentSource;
   async function reconnect() {
     logger.info(`Retrying connection in ${formatMs$1(retryInterval)} to Kubb Studio ...`);