@kubb/agent 5.0.0-alpha.17 → 5.0.0-alpha.19

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;
@@ -4674,23 +4613,6 @@ function camelCase$f(text, { isFile, 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}`);
@@ -4782,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);
         }
       };
@@ -5098,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) {
@@ -5106,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);
@@ -5126,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);
@@ -5138,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();
   }
@@ -5182,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("\\", "/");
@@ -5217,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 });
@@ -5362,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;
@@ -5390,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();
   }
@@ -5428,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 = {};
@@ -5437,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];
@@ -6126,7 +6107,7 @@ const fsStorage = createStorage(() => ({
     await clean(resolve(base));
   }
 }));
-var version$1 = "5.0.0-alpha.17";
+var version$1 = "5.0.0-alpha.19";
 function getDiagnosticInfo() {
   return {
     nodeVersion: version$2,
@@ -6684,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) {
@@ -6700,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);
@@ -6734,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 {
@@ -6914,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);
@@ -6942,7 +6940,7 @@ function satisfiesDependency(dependency, version2, cwd) {
   return satisfies(semVer, version2);
 }
 
-var version = "5.0.0-alpha.17";
+var version = "5.0.0-alpha.19";
 
 function isCommandMessage(msg) {
   return msg.type === "command";
@@ -7325,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;
@@ -7353,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();
   }
@@ -7391,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 = {};
@@ -7400,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];
@@ -9230,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;
@@ -9258,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();
   }
@@ -9296,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 = {};
@@ -9305,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];
@@ -9469,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;
@@ -9497,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();
   }
@@ -9535,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 = {};
@@ -9544,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];
@@ -211970,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;
@@ -211998,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();
   }
@@ -212036,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 = {};
@@ -212045,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];
@@ -213505,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;
@@ -213533,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();
   }
@@ -213571,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 = {};
@@ -213580,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];
@@ -213967,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) {
@@ -213981,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;
@@ -214009,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();
   }
@@ -214047,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 = {};
@@ -214056,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];
@@ -217051,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;
@@ -217079,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();
   }
@@ -217117,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 = {};
@@ -217126,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];
@@ -218201,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;
@@ -218229,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();
   }
@@ -218267,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 = {};
@@ -218276,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];
@@ -219351,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;
@@ -219379,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();
   }
@@ -219417,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 = {};
@@ -219426,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];
@@ -220514,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) {
@@ -220528,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;
@@ -220556,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();
   }
@@ -220594,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 = {};
@@ -220603,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];
@@ -222485,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 ...`);