@kubb/core 5.10.1 → 5.10.2

package/dist/{createAdapter-D55JE9lX.d.ts → createAdapter-CMnLz31B.d.ts}

@@ -84,647 +84,295 @@ type ParserFactory<TOptions extends object = object, TMeta extends object = obje
  */
 declare function defineParser<TOptions extends object = object, TMeta extends object = object, TNode = unknown>(definition: ParserDefinition<TOptions, TMeta, TNode>): ParserFactory<TOptions, TMeta, TNode>;
 //#endregion
-//#region src/createRenderer.d.ts
-/**
- * Minimal interface any Kubb renderer must satisfy.
- *
- * `TElement` is the type the renderer accepts, for example `KubbReactElement`
- * for `@kubb/renderer-jsx` or a custom type for your own renderer. Defaults to
- * `unknown` so generators that don't care about the element type work without
- * specifying it.
- */
-type Renderer<TElement = unknown> = {
-  /**
-   * Renders `element` and populates {@link files} with the resulting {@link FileNode} objects.
-   * Called once per render cycle. Must resolve before {@link files} is read.
-   */
-  render(element: TElement): Promise<void>;
-  /**
-   * Accumulated {@link FileNode} results produced by the last {@link render} call.
-   */
-  readonly files: Array<FileNode>;
-  /**
-   * Disposer hook so renderers participate in `using` blocks: `using r = rendererFactory()`
-   * runs cleanup on every exit path, including thrown errors.
-   */
-  [Symbol.dispose](): void;
-};
-/**
- * A factory function that produces a fresh {@link Renderer} per render cycle.
- *
- * Generators use this to declare which renderer handles their output.
- */
-type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
-/**
- * Defines a renderer factory. Renderers turn the generator's return value
- * (JSX, a template string, a tree of any shape) into `FileNode`s that get
- * written to disk.
- *
- * A renderer can target output formats beyond JSX, for instance a Handlebars
- * renderer or one that writes binary files. Plugins and generators pick the
- * renderer to use via the `renderer` field on `defineGenerator`.
- *
- * @example A minimal renderer that wraps a custom runtime
- * ```ts
- * import { createRenderer } from '@kubb/core'
- *
- * export const myRenderer = createRenderer(() => {
- *   const runtime = new MyRuntime()
- *   return {
- *     async render(element) {
- *       await runtime.render(element)
- *     },
- *     get files() {
- *       return runtime.files
- *     },
- *     [Symbol.dispose]() {
- *       runtime.dispose()
- *     },
- *   }
- * })
- * ```
- */
-declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
-//#endregion
-//#region src/constants.d.ts
-/**
- * Stable codes Kubb attaches to a `Diagnostic`. Each maps to a known failure mode
- * and stays stable so it can be referenced in tooling and (later) docs. Reference
- * these instead of inlining the string at a throw site.
- */
-declare const diagnosticCode: {
-  /**
-   * Fallback for an unstructured error with no specific code.
-   */
-  readonly unknown: "KUBB_UNKNOWN";
-  /**
-   * The file or URL set as `input` could not be read.
-   */
-  readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
-  /**
-   * A URL set as `input` (or referenced by a `$ref`) answered with a 4xx or 5xx status
-   * instead of the document.
-   */
-  readonly inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED";
-  /**
-   * A URL set as `input` (or referenced by a `$ref`) never answered, so the request failed
-   * before a status was returned.
-   */
-  readonly inputUnreachable: "KUBB_INPUT_UNREACHABLE";
-  /**
-   * An adapter was configured without an `input`.
-   */
-  readonly inputRequired: "KUBB_INPUT_REQUIRED";
-  /**
-   * `input` uses the v4 `{ path }` / `{ data }` wrapper, which v5 reads as a parsed
-   * document instead of a pointer to one.
-   */
-  readonly legacyInput: "KUBB_LEGACY_INPUT";
-  /**
-   * The parsed `input` carries no `openapi` or `swagger` version, so it is not a
-   * document the adapter can read.
-   */
-  readonly invalidDocument: "KUBB_INVALID_DOCUMENT";
-  /** The document fails OpenAPI schema validation. Reported as a warning. */
-  readonly invalidSpec: "KUBB_INVALID_SPEC";
-  /**
-   * A `$ref` (or equivalent reference) could not be resolved in the source document.
-   */
-  readonly refNotFound: "KUBB_REF_NOT_FOUND";
-  /**
-   * A server variable value is not allowed by its `enum`.
-   */
-  readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
-  /**
-   * A required plugin is missing from the config.
-   */
-  readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
-  /**
-   * The running Kubb or Node.js version is outside a plugin's `meta.compatibility`.
-   */
-  readonly incompatibleExtension: "KUBB_INCOMPATIBLE_EXTENSION";
-  /**
-   * A required entry in a plugin's `dependencies` record is missing from the config.
-   */
-  readonly missingDependency: "KUBB_MISSING_DEPENDENCY";
-  /**
-   * A dependency's `meta.version` is outside the range a plugin's `dependencies` record declares.
-   */
-  readonly incompatibleDependency: "KUBB_INCOMPATIBLE_DEPENDENCY";
-  /**
-   * A plugin threw while generating.
-   */
-  readonly pluginFailed: "KUBB_PLUGIN_FAILED";
-  /** An adapter threw while parsing the input. */
-  readonly adapterFailed: "KUBB_ADAPTER_FAILED";
-  /** A parser threw while printing a generated file. */
-  readonly parserFailed: "KUBB_PARSER_FAILED";
-  /**
-   * A plugin reported a non-fatal warning through `ctx.warn`.
-   */
-  readonly pluginWarning: "KUBB_PLUGIN_WARNING";
-  /**
-   * A plugin reported an informational message through `ctx.info`.
-   */
-  readonly pluginInfo: "KUBB_PLUGIN_INFO";
-  /**
-   * A `kubb/kit` composable was called outside a plugin's `setup` and `kubb:plugin:setup`.
-   */
-  readonly noContext: "KUBB_NO_CONTEXT";
-  /**
-   * A schema uses a `format` Kubb does not map to a specific type. Reserved for
-   * adapters to emit as a `warning`.
-   */
-  readonly unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT";
-  /**
-   * A referenced schema or operation is marked `deprecated`. Reserved for adapters
-   * to emit as an `info`.
-   */
-  readonly deprecated: "KUBB_DEPRECATED";
-  /**
-   * An adapter is required but the config has none. The build cannot read the input
-   * without one.
-   */
-  readonly adapterRequired: "KUBB_ADAPTER_REQUIRED";
-  /**
-   * A resolved output path escapes the output directory, which can stem from a path
-   * traversal in the spec or a misconfigured `group.name`.
-   */
-  readonly pathTraversal: "KUBB_PATH_TRAVERSAL";
-  /**
-   * `output.clean` is enabled but `output.path` resolves to the project root or a parent of it,
-   * so cleaning would delete kubb.config and every source file.
-   */
-  readonly cleanRoot: "KUBB_CLEAN_ROOT";
-  /**
-   * A plugin's options are invalid, for example `output.mode: 'file'` paired with a `group` option.
-   */
-  readonly invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS";
-  /**
-   * A post-generate command (`output.postGenerate`) exited with a failure.
-   */
-  readonly postGenerateFailed: "KUBB_POST_GENERATE_FAILED";
-  /**
-   * The formatter pass over the generated files failed.
-   */
-  readonly formatFailed: "KUBB_FORMAT_FAILED";
-  /**
-   * The linter pass over the generated files failed.
-   */
-  readonly lintFailed: "KUBB_LINT_FAILED";
-  /**
-   * A barrel tries to re-export the same name from more than one module.
-   */
-  readonly barrelDuplicateExport: "KUBB_BARREL_DUPLICATE_EXPORT";
-  /**
-   * Not a failure. Carries a plugin's elapsed time, summed into the run total.
-   */
-  readonly performance: "KUBB_PERFORMANCE";
-  /**
-   * Not a failure. A newer Kubb version is available on npm.
-   */
-  readonly updateAvailable: "KUBB_UPDATE_AVAILABLE";
-};
-/**
- * Union of the stable {@link diagnosticCode} values.
- */
-type DiagnosticCode = (typeof diagnosticCode)[keyof typeof diagnosticCode];
-//#endregion
-//#region src/Hookable.d.ts
-/**
- * A function that can be registered as a hook listener, synchronous or async. Any return value is
- * allowed and ignored, so handlers that return a result for their own callers still register.
- */
-type AsyncListener<TArgs extends Array<unknown>> = (...args: TArgs) => unknown;
-/**
- * Typed hook emitter that awaits all async listeners before resolving.
- *
- * @example
- * ```ts
- * const hooks = new Hookable<{ build: [name: string] }>()
- * hooks.hook('build', async (name) => { console.log(name) })
- * await hooks.callHook('build', 'petstore') // all listeners awaited
- * ```
- */
-declare class Hookable<THooks extends { [K in keyof THooks]: Array<unknown>; }> {
-  #private;
-  /**
-   * Calls `hookName` and awaits all registered listeners sequentially.
-   * Throws if any listener rejects, wrapping the cause in an error that names the hook.
-   *
-   * @example
-   * ```ts
-   * await hooks.callHook('build', 'petstore')
-   * ```
-   */
-  callHook<THookName extends keyof THooks & string>(hookName: THookName, ...hookArgs: THooks[THookName]): Promise<void> | void;
-  /**
-   * Registers a persistent listener for `hookName` and returns a function that removes it.
-   *
-   * @example
-   * ```ts
-   * const unhook = hooks.hook('build', async (name) => { console.log(name) })
-   * unhook() // removes it
-   * ```
-   */
-  hook<THookName extends keyof THooks & string>(hookName: THookName, handler: AsyncListener<THooks[THookName]>): () => void;
-  /**
-   * Registers every handler in `configHooks` at once and returns a function that removes them
-   * all. Undefined entries are skipped, so a partial hook object registers only its present keys.
-   *
-   * @example
-   * ```ts
-   * const unhook = hooks.addHooks({ build: onBuild, done: onDone })
-   * unhook() // removes both
-   * ```
-   */
-  addHooks(configHooks: Partial<{ [K in keyof THooks & string]: AsyncListener<THooks[K]>; }>): () => void;
-  /**
-   * Removes a previously registered listener.
-   *
-   * @example
-   * ```ts
-   * hooks.removeHook('build', handler)
-   * ```
-   */
-  removeHook<THookName extends keyof THooks & string>(hookName: THookName, handler: AsyncListener<THooks[THookName]>): void;
-  /**
-   * Returns the number of listeners registered for `hookName`.
-   *
-   * @example
-   * ```ts
-   * hooks.hook('build', handler)
-   * hooks.listenerCount('build') // 1
-   * ```
-   */
-  listenerCount<THookName extends keyof THooks & string>(hookName: THookName): number;
-  /**
-   * No-op kept for callers written against the `EventEmitter`-backed version. Listeners are unbounded.
-   *
-   * @deprecated There is no listener ceiling anymore.
-   */
-  setMaxListeners(_max: number): void;
-  /**
-   * Removes all listeners from every hook channel.
-   *
-   * @example
-   * ```ts
-   * hooks.removeAllHooks()
-   * ```
-   */
-  removeAllHooks(): void;
-}
-//#endregion
-//#region src/Diagnostics.d.ts
-/**
- * How serious a diagnostic is. `error` fails the build, `warning` and `info`
- * are reported but do not.
- */
-type DiagnosticSeverity = 'error' | 'warning' | 'info';
-/**
- * A human-readable explanation of a diagnostic code: a short title, what triggers it, and how
- * to resolve it. This is the source of truth the kubb.dev `/reference/diagnostics#<slug>` sections mirror, so
- * every code stays documented in one place. Adding a code without documenting it fails the build.
- */
-type DiagnosticDoc = {
-  /**
-   * Short title shown as the docs heading.
-   */
-  title: string;
-  /**
-   * What triggers the diagnostic.
-   */
-  cause: string;
-  /**
-   * The action that resolves it.
-   */
-  fix: string;
-};
-/**
- * Points a diagnostic back into the source document. Inputs are parsed into an
- * object model with no line/column, so locations carry a JSON pointer the adapter
- * builds (the OAS adapter emits `#/components/schemas/Pet`). A `config` diagnostic
- * points at the Kubb config itself and so has no pointer.
- */
-type DiagnosticLocation = {
-  kind: 'schema';
-  /**
-   * RFC 6901 JSON pointer into the source document.
-   */
-  pointer: string;
-  /**
-   * The original reference when the diagnostic stems from an unresolved one.
-   */
-  ref?: string;
-} | {
-  kind: 'operation' | 'document';
-  /**
-   * RFC 6901 JSON pointer into the source document.
-   */
-  pointer: string;
-} | {
-  kind: 'config';
-};
-/**
- * What a diagnostic carries.
- * - `problem` is a build issue shown to the user, and the only kind rendered as a problem.
- * - `performance` records a plugin's elapsed time.
- * - `update` is a version notice.
- */
-type DiagnosticKind = 'problem' | 'performance' | 'update';
-/**
- * Codes that describe a build problem: every {@link DiagnosticCode} except the
- * `performance` and `updateAvailable` codes, which ride on their own variants.
- */
-type ProblemCode = Exclude<DiagnosticCode, typeof diagnosticCode.performance | typeof diagnosticCode.updateAvailable>;
-/**
- * A build problem collected during a run, gathered into the result instead of
- * aborting on the first failure.
- */
-type ProblemDiagnostic = {
-  /**
-   * @default 'problem'
-   */
-  kind?: 'problem';
-  /**
-   * Stable identifier for the problem, from the {@link diagnosticCode} catalog.
-   */
-  code: ProblemCode;
-  severity: DiagnosticSeverity;
-  message: string;
-  location?: DiagnosticLocation;
-  /**
-   * A suggested fix, phrased as an action the user can take.
-   */
-  help?: string;
-  /**
-   * Name of the plugin or subsystem that produced the diagnostic.
-   */
-  plugin?: string;
-  /** Issue tracker URL of the extension that crashed, from its `meta.issues`. */
-  issues?: string;
-  /**
-   * The underlying error, when the diagnostic wraps a thrown one.
-   */
-  cause?: Error;
-};
-/**
- * A per-plugin performance record, built with {@link Diagnostics.performance}. The `performance`
- * kind keeps it out of the problem list. It feeds the per-plugin timing bars, and reporters sum
- * these into the run total.
- */
-type PerformanceDiagnostic = {
-  kind: 'performance';
-  code: typeof diagnosticCode.performance;
-  severity: 'info';
-  message: string;
-  /**
-   * The plugin this measurement belongs to.
-   */
-  plugin: string;
-  /**
-   * Elapsed milliseconds.
-   */
-  duration: number;
-};
-/**
- * A notice that a newer Kubb version is available on npm, built with {@link Diagnostics.update}.
- * It renders like any info diagnostic.
- */
-type UpdateDiagnostic = {
-  kind: 'update';
-  code: typeof diagnosticCode.updateAvailable;
-  severity: 'info';
-  message: string;
-  /**
-   * The running Kubb version.
-   */
-  currentVersion: string;
-  /**
-   * The newest version published on npm.
-   */
-  latestVersion: string;
-};
-/**
- * A structured record collected during a build, discriminated on `kind`: a
- * {@link ProblemDiagnostic} for an issue, a {@link PerformanceDiagnostic} for a per-plugin
- * timing, or an {@link UpdateDiagnostic} for a version notice.
- */
-type Diagnostic = ProblemDiagnostic | PerformanceDiagnostic | UpdateDiagnostic;
-/**
- * A {@link Diagnostic} reduced to its JSON-safe fields plus a `docsUrl`, for
- * machine-readable output (the `--reporter json` report, the MCP tools). Drops the
- * non-serializable `cause` and the `kind`/`duration` bookkeeping.
- */
-type SerializedDiagnostic = {
-  code: DiagnosticCode;
-  severity: DiagnosticSeverity;
-  message: string;
-  location?: DiagnosticLocation;
-  help?: string;
-  plugin?: string;
-  issues?: string;
-  /**
-   * The kubb.dev docs link for the code, omitted for the unknown fallback.
-   */
-  docsUrl?: string;
-};
-/**
- * Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
- * that lets deep code report a diagnostic without threading a callback.
- *
- * The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
- * `Diagnostics.scope` activates it for a run, so anything inside that run (the
- * adapter parse, a generator) reports through `Diagnostics.report` and lands
- * in the same run.
- */
-declare class Diagnostics {
-  #private;
-  /**
-   * The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
-   */
-  static code: {
-    readonly unknown: "KUBB_UNKNOWN";
-    readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
-    readonly inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED";
-    readonly inputUnreachable: "KUBB_INPUT_UNREACHABLE";
-    readonly inputRequired: "KUBB_INPUT_REQUIRED";
-    readonly legacyInput: "KUBB_LEGACY_INPUT";
-    readonly invalidDocument: "KUBB_INVALID_DOCUMENT";
-    readonly invalidSpec: "KUBB_INVALID_SPEC";
-    readonly refNotFound: "KUBB_REF_NOT_FOUND";
-    readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
-    readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
-    readonly incompatibleExtension: "KUBB_INCOMPATIBLE_EXTENSION";
-    readonly missingDependency: "KUBB_MISSING_DEPENDENCY";
-    readonly incompatibleDependency: "KUBB_INCOMPATIBLE_DEPENDENCY";
-    readonly pluginFailed: "KUBB_PLUGIN_FAILED";
-    readonly adapterFailed: "KUBB_ADAPTER_FAILED";
-    readonly parserFailed: "KUBB_PARSER_FAILED";
-    readonly pluginWarning: "KUBB_PLUGIN_WARNING";
-    readonly pluginInfo: "KUBB_PLUGIN_INFO";
-    readonly noContext: "KUBB_NO_CONTEXT";
-    readonly unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT";
-    readonly deprecated: "KUBB_DEPRECATED";
-    readonly adapterRequired: "KUBB_ADAPTER_REQUIRED";
-    readonly pathTraversal: "KUBB_PATH_TRAVERSAL";
-    readonly cleanRoot: "KUBB_CLEAN_ROOT";
-    readonly invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS";
-    readonly postGenerateFailed: "KUBB_POST_GENERATE_FAILED";
-    readonly formatFailed: "KUBB_FORMAT_FAILED";
-    readonly lintFailed: "KUBB_LINT_FAILED";
-    readonly barrelDuplicateExport: "KUBB_BARREL_DUPLICATE_EXPORT";
-    readonly performance: "KUBB_PERFORMANCE";
-    readonly updateAvailable: "KUBB_UPDATE_AVAILABLE";
+//#region src/diagnosticCatalog.d.ts
+/**
+ * Every diagnostic code with its docs entry: a short title, what triggers it, and how to resolve
+ * it. The source of truth for {@link diagnosticCode}, and the kubb.dev `/reference/diagnostics`
+ * sections mirror it.
+ */
+declare const diagnosticCatalog: {
+  readonly unknown: {
+    readonly code: "KUBB_UNKNOWN";
+    readonly title: "Unknown error";
+    readonly cause: "An error was thrown without a stable Kubb code, so it is reported as-is.";
+    readonly fix: "Read the underlying message and stack. If it comes from a plugin or adapter, check its configuration; otherwise report it as a possible Kubb bug.";
   };
-  /**
-   * Type guard for a build {@link ProblemDiagnostic}.
-   */
-  static isProblem: (diagnostic: Diagnostic) => diagnostic is ProblemDiagnostic;
-  /**
-   * Type guard for a version-update {@link UpdateDiagnostic}.
-   */
-  static isUpdate: (diagnostic: Diagnostic) => diagnostic is UpdateDiagnostic;
-  /**
-   * Type guard for a per-plugin {@link PerformanceDiagnostic}.
-   */
-  static isPerformance: (diagnostic: Diagnostic) => diagnostic is PerformanceDiagnostic;
-  /**
-   * An `Error` that carries a {@link Diagnostic}, so structured problems can flow
-   * through the existing throw/catch paths while keeping their code and location.
-   *
-   * @example
-   * ```ts
-   * throw new Diagnostics.Error({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
-   * ```
-   */
-  static Error: {
-    new (diagnostic: ProblemDiagnostic): {
-      diagnostic: ProblemDiagnostic;
-      name: string;
-      message: string;
-      stack?: string;
-      cause?: unknown;
-    };
-    isError(error: unknown): error is Error;
-    isError(value: unknown): value is Error;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
-    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
-    stackTraceLimit: number;
+  readonly inputNotFound: {
+    readonly code: "KUBB_INPUT_NOT_FOUND";
+    readonly title: "Input not found";
+    readonly cause: "The file set as `input` (or passed as `kubb generate PATH`) could not be read. A URL reports `KUBB_INPUT_REQUEST_FAILED` or `KUBB_INPUT_UNREACHABLE` instead.";
+    readonly fix: "Check that the path exists and is readable, then set it as `input` or pass it on the CLI.";
+  };
+  readonly inputRequestFailed: {
+    readonly code: "KUBB_INPUT_REQUEST_FAILED";
+    readonly title: "Input request failed";
+    readonly cause: "A URL set as `input` (or reached through a `$ref`) answered with a 4xx or 5xx status instead of the document.";
+    readonly fix: "Open the URL to see what the server returns. A 401 or 403 needs credentials Kubb does not send, so download the document and point `input` at the local file. A 404 means the path is wrong, and a 5xx means the server itself failed.";
+  };
+  readonly inputUnreachable: {
+    readonly code: "KUBB_INPUT_UNREACHABLE";
+    readonly title: "Input unreachable";
+    readonly cause: "A URL set as `input` (or reached through a `$ref`) never answered, so the request failed before a status came back. A refused connection, an unknown host, an expired certificate, and a timeout all land here.";
+    readonly fix: "Check that the host is running and reachable from this machine. For a local server, start it and confirm the port matches the one in `input`.";
+  };
+  readonly inputRequired: {
+    readonly code: "KUBB_INPUT_REQUIRED";
+    readonly title: "Input required";
+    readonly cause: "An adapter is configured but no `input` was provided.";
+    readonly fix: "Set `input` to a file path, a URL, an inline spec (JSON/YAML string), or a parsed object in your Kubb config.";
+  };
+  readonly legacyInput: {
+    readonly code: "KUBB_LEGACY_INPUT";
+    readonly title: "Legacy input shape";
+    readonly cause: "`input` is a `{ path }` or `{ data }` wrapper, which v4 used to point at a document and v5 reads as the document itself.";
+    readonly fix: "Unwrap it: `input: { path: \"./petStore.yaml\" }` becomes `input: \"./petStore.yaml\"`, and `input: { data: spec }` becomes `input: spec`.";
+  };
+  readonly invalidDocument: {
+    readonly code: "KUBB_INVALID_DOCUMENT";
+    readonly title: "Invalid document";
+    readonly cause: "The `input` cannot be read as an OpenAPI or Swagger document: its JSON or YAML has a syntax error, it declares no `openapi` or `swagger` version field, or its version cannot be upgraded to OpenAPI 3.1.";
+    readonly fix: "Fix the syntax at the reported line, and check that `input` points at the spec and not an HTML page. Point `input` at a Swagger 2.0, OpenAPI 3.0, or OpenAPI 3.1 document, and check that a passed object is the spec itself rather than a wrapper around it.";
+  };
+  readonly invalidSpec: {
+    readonly code: "KUBB_INVALID_SPEC";
+    readonly title: "Invalid spec";
+    readonly cause: "The document does not pass OpenAPI schema validation. Kubb still generates from it, but the output can be incomplete or wrong.";
+    readonly fix: "Fix the reported problem in the spec. Run `kubb validate` to list every error, or set `validate: false` on the adapter to skip the check.";
+  };
+  readonly refNotFound: {
+    readonly code: "KUBB_REF_NOT_FOUND";
+    readonly title: "Reference not found";
+    readonly cause: "A `$ref` could not be resolved in the source document.";
+    readonly fix: "Add the missing definition (for example under `components.schemas`) or fix the `$ref`. Run `kubb validate` to check the spec.";
+  };
+  readonly invalidServerVariable: {
+    readonly code: "KUBB_INVALID_SERVER_VARIABLE";
+    readonly title: "Invalid server variable";
+    readonly cause: "A server variable value is not allowed by its `enum`.";
+    readonly fix: "Use one of the values listed in the server variable `enum`, or update the spec.";
+  };
+  readonly pluginNotFound: {
+    readonly code: "KUBB_PLUGIN_NOT_FOUND";
+    readonly title: "Plugin not found";
+    readonly cause: "A plugin that another plugin depends on is missing from the config.";
+    readonly fix: "Add the required plugin to the `plugins` array in kubb.config.ts, or remove the dependency on it.";
+  };
+  readonly incompatibleExtension: {
+    readonly code: "KUBB_INCOMPATIBLE_EXTENSION";
+    readonly title: "Incompatible extension";
+    readonly cause: "A plugin sets `meta.compatibility.kubb` or `meta.compatibility.node` to a range the running Kubb or Node.js version does not satisfy.";
+    readonly fix: "Upgrade Kubb or Node.js to a version in the range, or install a version of the plugin that supports your current Kubb and Node.js.";
+  };
+  readonly missingDependency: {
+    readonly code: "KUBB_MISSING_DEPENDENCY";
+    readonly title: "Missing dependency";
+    readonly cause: "A plugin lists another plugin in its `dependencies` record without `optional: true`, and the config does not include it.";
+    readonly fix: "Add the missing plugin to the `plugins` array in kubb.config.ts.";
+  };
+  readonly incompatibleDependency: {
+    readonly code: "KUBB_INCOMPATIBLE_DEPENDENCY";
+    readonly title: "Incompatible dependency";
+    readonly cause: "A plugin's `dependencies` record sets a `version` range, and the configured plugin's `meta.version` falls outside it.";
+    readonly fix: "Install a version of the dependency inside the range, or a version of the dependent plugin that supports the installed dependency.";
+  };
+  readonly pluginFailed: {
+    readonly code: "KUBB_PLUGIN_FAILED";
+    readonly title: "Plugin failed";
+    readonly cause: "A plugin threw while generating, or reported an error through `ctx.error`.";
+    readonly fix: "Check the plugin options and the node at `at:`. If it is a bug, report it with the stack at `report:`.";
+  };
+  readonly adapterFailed: {
+    readonly code: "KUBB_ADAPTER_FAILED";
+    readonly title: "Adapter failed";
+    readonly cause: "The adapter threw an unexpected error while parsing the input.";
+    readonly fix: "Check the input and the adapter options. If it is a bug, report it with the stack at `report:`.";
+  };
+  readonly parserFailed: {
+    readonly code: "KUBB_PARSER_FAILED";
+    readonly title: "Parser failed";
+    readonly cause: "A parser threw an unexpected error while printing a generated file.";
+    readonly fix: "Check the parser options. If it is a bug, report it with the stack at `report:`.";
+  };
+  readonly pluginWarning: {
+    readonly code: "KUBB_PLUGIN_WARNING";
+    readonly title: "Plugin warning";
+    readonly cause: "A plugin reported a non-fatal warning through `ctx.warn`.";
+    readonly fix: "Review the message. It does not fail the build; adjust the plugin options or input if the warning is unwanted.";
+  };
+  readonly pluginInfo: {
+    readonly code: "KUBB_PLUGIN_INFO";
+    readonly title: "Plugin info";
+    readonly cause: "A plugin reported an informational message through `ctx.info`.";
+    readonly fix: "Informational only. No action is required.";
+  };
+  readonly noContext: {
+    readonly code: "KUBB_NO_CONTEXT";
+    readonly title: "No plugin context";
+    readonly cause: "A `kubb/kit` composable such as `useKubb()` or `addGenerator()` ran outside the `setup` and `kubb:plugin:setup` of a plugin, so there is no plugin to apply it to.";
+    readonly fix: "Call the composable inside `setup` or `kubb:plugin:setup`, including in code that setup awaits.";
+  };
+  readonly unsupportedFormat: {
+    readonly code: "KUBB_UNSUPPORTED_FORMAT";
+    readonly title: "Unsupported format";
+    readonly cause: "A schema uses a `format` Kubb does not map to a specific type, so it falls back to the base type.";
+    readonly fix: "Use a format Kubb supports, or handle the custom format with a parser or plugin.";
+  };
+  readonly deprecated: {
+    readonly code: "KUBB_DEPRECATED";
+    readonly title: "Deprecated";
+    readonly cause: "A referenced schema or operation is marked `deprecated`.";
+    readonly fix: "Migrate off the deprecated definition if the warning is unwanted.";
+  };
+  readonly adapterRequired: {
+    readonly code: "KUBB_ADAPTER_REQUIRED";
+    readonly title: "Adapter required";
+    readonly cause: "An action needs an adapter but none is configured.";
+    readonly fix: "Set `adapter` in kubb.config.ts, for example `adapterOas()`.";
+  };
+  readonly pathTraversal: {
+    readonly code: "KUBB_PATH_TRAVERSAL";
+    readonly title: "Path traversal";
+    readonly cause: "A resolved output path escaped the output directory, which can stem from a path traversal in the spec or a misconfigured `group.name`.";
+    readonly fix: "Keep generated paths within the output directory. Review the `group.name` function and the names coming from the spec.";
+  };
+  readonly cleanRoot: {
+    readonly code: "KUBB_CLEAN_ROOT";
+    readonly title: "Clean targets the project root";
+    readonly cause: "`output.clean` is enabled and `output.path` resolves to the project root or a parent of it, so cleaning would delete `kubb.config` and every source file.";
+    readonly fix: "Point `output.path` at a subdirectory such as `./src/gen` so clean only removes generated code, or disable `output.clean`.";
+  };
+  readonly invalidPluginOptions: {
+    readonly code: "KUBB_INVALID_PLUGIN_OPTIONS";
+    readonly title: "Invalid plugin options";
+    readonly cause: "A plugin was configured with options that cannot be honored, for example `output.mode: 'file'` paired with a `group` option.";
+    readonly fix: "Fix the plugin options. A single-file output has nothing to group, so remove the `group` option or use `output.mode: 'directory'`.";
+  };
+  readonly postGenerateFailed: {
+    readonly code: "KUBB_POST_GENERATE_FAILED";
+    readonly title: "Post-generate command failed";
+    readonly cause: "A post-generate command (`output.postGenerate`) exited with a non-zero status.";
+    readonly fix: "Check the command is installed and correct, and run it manually to see the error.";
+  };
+  readonly formatFailed: {
+    readonly code: "KUBB_FORMAT_FAILED";
+    readonly title: "Format failed";
+    readonly cause: "The formatter pass over the generated files failed.";
+    readonly fix: "Check the formatter (oxfmt, biome, or prettier) is installed and its config is valid, then run it manually on the output.";
+  };
+  readonly lintFailed: {
+    readonly code: "KUBB_LINT_FAILED";
+    readonly title: "Lint failed";
+    readonly cause: "The linter pass over the generated files failed.";
+    readonly fix: "Check the linter (oxlint, biome, or eslint) is installed and its config is valid, then run it manually on the output.";
   };
+  readonly barrelDuplicateExport: {
+    readonly code: "KUBB_BARREL_DUPLICATE_EXPORT";
+    readonly title: "Duplicate barrel export";
+    readonly cause: "Two generated modules export the same name, so the barrel cannot re-export both.";
+    readonly fix: "Rename one of the colliding declarations, or configure the plugin resolver to produce distinct names.";
+  };
+  readonly internalError: {
+    readonly code: "KUBB_INTERNAL_ERROR";
+    readonly title: "Internal error";
+    readonly cause: "Kubb hit a state it does not expect. This is a bug in Kubb, not in your config.";
+    readonly fix: "Rerun with `--reporter json` or `--verbose` to get the stack. Then report it at https://github.com/kubb-labs/kubb/issues with the spec and config that trigger it.";
+  };
+  readonly performance: {
+    readonly code: "KUBB_PERFORMANCE";
+    readonly title: "Performance";
+    readonly cause: "Not a failure. Records a plugin’s elapsed time, summed into the run total.";
+    readonly fix: "No action. This is an informational metric.";
+  };
+  readonly updateAvailable: {
+    readonly code: "KUBB_UPDATE_AVAILABLE";
+    readonly title: "Update available";
+    readonly cause: "A newer Kubb version is published on npm than the one running.";
+    readonly fix: "Update the `@kubb/*` packages, for example `npm install -g @kubb/cli`, to get the latest fixes.";
+  };
+};
+/**
+ * Stable codes Kubb attaches to a `Diagnostic`, derived from {@link diagnosticCatalog}. Reference
+ * these instead of inlining the string at a throw site.
+ */
+declare const diagnosticCode: { readonly [K in keyof typeof diagnosticCatalog]: (typeof diagnosticCatalog)[K]["code"]; };
+/**
+ * Union of the stable {@link diagnosticCode} values.
+ */
+type DiagnosticCode = (typeof diagnosticCode)[keyof typeof diagnosticCode];
+//#endregion
+//#region src/formatDiagnostic.d.ts
+/**
+ * How {@link format} renders a diagnostic.
+ */
+type DiagnosticFormatOptions = {
   /**
-   * Structural check for a {@link Diagnostics.Error}, including one thrown from a duplicated
-   * `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
-   * that carries a `code`.
-   */
-  static isError(error: unknown): error is InstanceType<typeof Diagnostics.Error>;
-  /**
-   * Runs `fn` with `sink` as the active diagnostic sink for the whole async
-   * subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
-   */
-  static scope<T>(sink: (diagnostic: Diagnostic) => void, fn: () => T): T;
-  /**
-   * Collects a diagnostic into the active build via the run-scoped sink, without throwing.
-   * Returns `true` when a run consumed it, `false` when called outside a {@link Diagnostics.scope}
-   * (so callers can fall back to throwing). Use a `warning`/`info` severity for non-fatal issues.
-   * For rendering a diagnostic live on the hook bus, use {@link Diagnostics.emit} instead.
-   */
-  static report(diagnostic: Diagnostic): boolean;
-  /**
-   * Emits a diagnostic on the run's `kubb:diagnostic` hook so the loggers render it live.
-   * Use it instead of calling `hooks.callHook('kubb:diagnostic', ...)` directly. To collect a
-   * diagnostic into the build result from deep in a run, use {@link Diagnostics.report} instead.
-   */
-  static emit(hooks: Hookable<KubbHooks>, diagnostic: ProblemDiagnostic | UpdateDiagnostic): Promise<void>;
-  /**
-   * Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
-   * keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
-   */
-  static from(error: unknown): ProblemDiagnostic;
-  /**
-   * Coerces an error thrown by a plugin, adapter, or parser into a diagnostic attributed to it.
-   * A structured {@link Diagnostics.Error} keeps its code. Any other error is a crash: it gets the
-   * kind's `*_FAILED` code and the extension's `meta.issues` link, so the user reports it to the
-   * extension's maintainers instead of to Kubb.
-   */
-  static fromExtension(error: unknown, { kind, extension }: {
-    kind: ExtensionKind;
-    extension: ExtensionNamed;
-  }): ProblemDiagnostic;
-  /**
-   * Builds a per-plugin performance record. Reporters sum these into the run total.
-   */
-  static performance({ plugin, duration }: {
-    plugin: string;
-    duration: number;
-  }): PerformanceDiagnostic;
-  /**
-   * Builds the version-update notice shown when a newer Kubb is published on npm.
-   */
-  static update({ currentVersion, latestVersion }: {
-    currentVersion: string;
-    latestVersion: string;
-  }): UpdateDiagnostic;
-  /**
-   * True when any diagnostic is an error, the severity that fails a build. Non-error
-   * diagnostics are ignored.
+   * Who reads the output.
+   * - `'agent'` spells out every detail on labeled rows
+   * - `'human'` keeps it short and links to the docs
+   * @default 'agent'
    */
-  static hasError(diagnostics: ReadonlyArray<Diagnostic>): boolean;
+  audience?: 'agent' | 'human';
   /**
-   * Names of the plugins that failed, deduped, derived from the error diagnostics
-   * that carry a `plugin`.
+   * Show the root cause's full stack.
    */
-  static failedPlugins(diagnostics: ReadonlyArray<Diagnostic>): Array<string>;
+  verbose?: boolean;
   /**
-   * Counts `problem` diagnostics by severity for the run summary. `performance` and
-   * `update` diagnostics are ignored.
+   * Columns the `human` headline fills, so the code lines up at the right edge.
+   * @default 0
    */
-  static count(diagnostics: ReadonlyArray<Diagnostic>): {
-    errors: number;
-    warnings: number;
-    infos: number;
-  };
+  width?: number;
+};
+/**
+ * A {@link Diagnostic} reduced to its JSON-safe fields plus a `docsUrl`, for
+ * machine-readable output (the `--reporter json` report, the MCP tools). Replaces the
+ * non-serializable `cause` with its message chain and drops the `kind`/`duration` bookkeeping.
+ */
+type SerializedDiagnostic = {
+  code: DiagnosticCode;
+  severity: DiagnosticSeverity;
+  message: string;
   /**
-   * Drops duplicate `problem` diagnostics that share a code, location pointer, and
-   * plugin, so the same issue reported across several passes is shown once. Non-problem
-   * diagnostics are always kept.
+   * Catalog title.
    */
-  static dedupe(diagnostics: ReadonlyArray<Diagnostic>): Array<Diagnostic>;
+  title?: string;
   /**
-   * Builds the kubb.dev docs URL for a diagnostic code, e.g.
-   * `KUBB_REF_NOT_FOUND` → `https://kubb.dev/docs/5.x/reference/diagnostics#kubb-ref-not-found`.
+   * Catalog cause.
    */
-  static docsUrl(code: string): string;
+  cause?: string;
+  location?: DiagnosticLocation;
   /**
-   * The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
-   * `/reference/diagnostics#<slug>` section.
+   * The diagnostic's `help`, or the catalog fix.
    */
-  static explain(code: DiagnosticCode): DiagnosticDoc;
+  help?: string;
+  plugin?: string;
+  issues?: string;
   /**
-   * Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
-   * consumers. The `cause`, `kind`, and `duration` are dropped, and absent optional
-   * fields are omitted rather than set to `undefined`.
+   * Messages of the underlying errors, outermost first.
    */
-  static serialize(diagnostic: Diagnostic): SerializedDiagnostic;
+  causes?: Array<string>;
   /**
-   * Renders a {@link Diagnostic} for terminal output as its parts: the `headline`
-   * (`[CODE] plugin: message`, with the code in the severity color) and the indented `details`
-   * rows (`at:` pointer, `fix:` help, `see:` docs link, `report:` issue tracker).
-   *
-   * Hosts compose these to fit their gutter: a clack logger passes `[headline, ...details]` as the
-   * message with no gutter symbol, while plain text outputs use {@link Diagnostics.formatLines}.
+   * Root cause's stack, for `KUBB_UNKNOWN`, `KUBB_INTERNAL_ERROR`, and `*_FAILED` codes.
    */
-  static format(diagnostic: Diagnostic): {
-    headline: string;
-    details: Array<string>;
-  };
+  stack?: string;
   /**
-   * The self-contained block form of {@link Diagnostics.format}: the `headline` followed by the
-   * indented detail rows. Used where there is no gutter (plain and file output).
+   * The kubb.dev docs link for the code, omitted for the unknown fallback.
    */
-  static formatLines(diagnostic: Diagnostic): Array<string>;
-}
+  docsUrl?: string;
+};
+/**
+ * Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+ * consumers, with the catalog `title`, `cause`, and fix, and the `cause` error as `causes` and
+ * `stack`. Absent optional fields are omitted.
+ */
+declare function serialize(diagnostic: Diagnostic): SerializedDiagnostic;
+/**
+ * Renders a {@link Diagnostic} as lines: a headline, then indented detail rows. `agent` (the default)
+ * prints uncolored labeled rows (`at:`, `why:`, `fix:`, `caused by:`, `stack:` for a crash,
+ * `docs:`, `report:`). `human` prints an icon, the bold message, and the code aligned to `width`,
+ * with `at`, `fix`, the first cause, and `Learn more` for an error, and one row for a warning.
+ * `verbose` adds the full stack.
+ */
+declare function format(diagnostic: Diagnostic, { audience, verbose, width }?: DiagnosticFormatOptions): Array<string>;
 //#endregion
 //#region src/createReporter.d.ts
 /**
@@ -934,6 +582,68 @@ type Storage = {
  */
 declare const createStorage: <TOptions = Record<string, never>>(build: (options: TOptions) => Storage) => (options?: TOptions) => Storage;
 //#endregion
+//#region src/createRenderer.d.ts
+/**
+ * Minimal interface any Kubb renderer must satisfy.
+ *
+ * `TElement` is the type the renderer accepts, for example `KubbReactElement`
+ * for `@kubb/renderer-jsx` or a custom type for your own renderer. Defaults to
+ * `unknown` so generators that don't care about the element type work without
+ * specifying it.
+ */
+type Renderer<TElement = unknown> = {
+  /**
+   * Renders `element` and populates {@link files} with the resulting {@link FileNode} objects.
+   * Called once per render cycle. Must resolve before {@link files} is read.
+   */
+  render(element: TElement): Promise<void>;
+  /**
+   * Accumulated {@link FileNode} results produced by the last {@link render} call.
+   */
+  readonly files: Array<FileNode>;
+  /**
+   * Disposer hook so renderers participate in `using` blocks: `using r = rendererFactory()`
+   * runs cleanup on every exit path, including thrown errors.
+   */
+  [Symbol.dispose](): void;
+};
+/**
+ * A factory function that produces a fresh {@link Renderer} per render cycle.
+ *
+ * Generators use this to declare which renderer handles their output.
+ */
+type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
+/**
+ * Defines a renderer factory. Renderers turn the generator's return value
+ * (JSX, a template string, a tree of any shape) into `FileNode`s that get
+ * written to disk.
+ *
+ * A renderer can target output formats beyond JSX, for instance a Handlebars
+ * renderer or one that writes binary files. Plugins and generators pick the
+ * renderer to use via the `renderer` field on `defineGenerator`.
+ *
+ * @example A minimal renderer that wraps a custom runtime
+ * ```ts
+ * import { createRenderer } from '@kubb/core'
+ *
+ * export const myRenderer = createRenderer(() => {
+ *   const runtime = new MyRuntime()
+ *   return {
+ *     async render(element) {
+ *       await runtime.render(element)
+ *     },
+ *     get files() {
+ *       return runtime.files
+ *     },
+ *     [Symbol.dispose]() {
+ *       runtime.dispose()
+ *     },
+ *   }
+ * })
+ * ```
+ */
+declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
+//#endregion
 //#region src/outputManifest.d.ts
 /**
  * Remembers what the output passes did to each generated file, so the next run can tell "the
@@ -967,6 +677,91 @@ type OutputManifest = {
   commit(): Promise<void>;
 };
 //#endregion
+//#region src/Hookable.d.ts
+/**
+ * A function that can be registered as a hook listener, synchronous or async. Any return value is
+ * allowed and ignored, so handlers that return a result for their own callers still register.
+ */
+type AsyncListener<TArgs extends Array<unknown>> = (...args: TArgs) => unknown;
+/**
+ * Typed hook emitter that awaits all async listeners before resolving.
+ *
+ * @example
+ * ```ts
+ * const hooks = new Hookable<{ build: [name: string] }>()
+ * hooks.hook('build', async (name) => { console.log(name) })
+ * await hooks.callHook('build', 'petstore') // all listeners awaited
+ * ```
+ */
+declare class Hookable<THooks extends { [K in keyof THooks]: Array<unknown>; }> {
+  #private;
+  /**
+   * Calls `hookName` and awaits all registered listeners sequentially.
+   * Throws if any listener rejects, wrapping the cause in an error that names the hook.
+   *
+   * @example
+   * ```ts
+   * await hooks.callHook('build', 'petstore')
+   * ```
+   */
+  callHook<THookName extends keyof THooks & string>(hookName: THookName, ...hookArgs: THooks[THookName]): Promise<void> | void;
+  /**
+   * Registers a persistent listener for `hookName` and returns a function that removes it.
+   *
+   * @example
+   * ```ts
+   * const unhook = hooks.hook('build', async (name) => { console.log(name) })
+   * unhook() // removes it
+   * ```
+   */
+  hook<THookName extends keyof THooks & string>(hookName: THookName, handler: AsyncListener<THooks[THookName]>): () => void;
+  /**
+   * Registers every handler in `configHooks` at once and returns a function that removes them
+   * all. Undefined entries are skipped, so a partial hook object registers only its present keys.
+   *
+   * @example
+   * ```ts
+   * const unhook = hooks.addHooks({ build: onBuild, done: onDone })
+   * unhook() // removes both
+   * ```
+   */
+  addHooks(configHooks: Partial<{ [K in keyof THooks & string]: AsyncListener<THooks[K]>; }>): () => void;
+  /**
+   * Removes a previously registered listener.
+   *
+   * @example
+   * ```ts
+   * hooks.removeHook('build', handler)
+   * ```
+   */
+  removeHook<THookName extends keyof THooks & string>(hookName: THookName, handler: AsyncListener<THooks[THookName]>): void;
+  /**
+   * Returns the number of listeners registered for `hookName`.
+   *
+   * @example
+   * ```ts
+   * hooks.hook('build', handler)
+   * hooks.listenerCount('build') // 1
+   * ```
+   */
+  listenerCount<THookName extends keyof THooks & string>(hookName: THookName): number;
+  /**
+   * No-op kept for callers written against the `EventEmitter`-backed version. Listeners are unbounded.
+   *
+   * @deprecated There is no listener ceiling anymore.
+   */
+  setMaxListeners(_max: number): void;
+  /**
+   * Removes all listeners from every hook channel.
+   *
+   * @example
+   * ```ts
+   * hooks.removeAllHooks()
+   * ```
+   */
+  removeAllHooks(): void;
+}
+//#endregion
 //#region src/FileManager.d.ts
 type ParseOptions = {
   parsers?: Map<FileNode['extname'], Parser>;
@@ -1672,155 +1467,477 @@ type KubbErrorContext = {
   /**
    * Optional structured metadata for additional context.
    */
-  meta?: Record<string, unknown>;
-};
-type KubbDiagnosticContext = {
+  meta?: Record<string, unknown>;
+};
+type KubbDiagnosticContext = {
+  /**
+   * The structured diagnostic to render: a build problem or a version-update notice.
+   */
+  diagnostic: ProblemDiagnostic | UpdateDiagnostic;
+};
+type KubbGenerationSummaryContext = {
+  duration: number;
+  fileCount: number;
+  failedPlugins: number;
+  status: 'success' | 'failed';
+};
+type KubbFilesProcessingStartContext = {
+  /**
+   * Files about to be serialized and written.
+   */
+  files: Array<FileNode>;
+};
+type KubbFileProcessingUpdate = {
+  /**
+   * Number of files processed so far in this batch.
+   */
+  processed: number;
+  /**
+   * Total number of files in this batch.
+   */
+  total: number;
+  /**
+   * Completion percentage, `0` to `100`.
+   */
+  percentage: number;
+  /**
+   * The file that was just processed.
+   */
+  file: FileNode;
+  /**
+   * Resolved configuration for this build.
+   */
+  config: Config;
+};
+type KubbFilesProcessingUpdateContext = {
+  /**
+   * All files processed in this flush chunk.
+   */
+  files: Array<KubbFileProcessingUpdate>;
+};
+type KubbFilesProcessingEndContext = {
+  /**
+   * All files that were serialized in this batch.
+   */
+  files: Array<FileNode>;
+};
+type KubbHookStartContext = {
+  /**
+   * Optional identifier for correlating start/end hooks.
+   */
+  id?: string;
+  /**
+   * The shell command that is about to run.
+   */
+  command: string;
+  /**
+   * Optional label for the command, shown in the CLI output when set.
+   */
+  name?: string;
+  /**
+   * Parsed argument list, when available.
+   */
+  args?: ReadonlyArray<string>;
+};
+/**
+ * Emitted for each line streamed from a hook's stdout while it runs.
+ * A logger correlates the line to its active UI element via `id`.
+ */
+type KubbHookLineContext = {
+  /**
+   * Identifier matching the corresponding `kubb:hook:start` hook.
+   */
+  id: string;
+  /**
+   * A single streamed stdout line, without its trailing newline.
+   */
+  line: string;
+};
+/** Emitted when a hook subprocess ends: its `kubb:hook:start` context plus the outcome. */
+type KubbHookEndContext = KubbHookStartContext & HookResult;
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
+  /**
+   * Path to the Kubb config file.
+   */
+  config?: string;
+  /**
+   * OpenAPI input path or URL passed as the positional argument to `kubb generate`.
+   * Overrides `config.input` when set.
+   */
+  input?: string;
+  /**
+   * Re-run generation whenever input files change.
+   */
+  watch?: boolean;
+  /**
+   * Controls how much output the CLI prints.
+   *
+   * @default 'info'
+   */
+  logLevel?: 'silent' | 'info' | 'verbose';
+  /**
+   * Reporters selected on the CLI via `--reporter`, overriding `config.reporters`.
+   */
+  reporters?: Array<ReporterName>;
+};
+/**
+ * All accepted forms of a Kubb configuration.
+ * Accepts `Config`/`Config[]`/promise or a factory (optionally receiving `TCliOptions`).
+ */
+type PossibleConfig<TCliOptions = undefined> = PossiblePromise<Config | Array<Config>> | ((...args: [TCliOptions] extends [undefined] ? [] : [TCliOptions]) => PossiblePromise<Config | Array<Config>>);
+/**
+ * Full output produced by a successful or failed build.
+ */
+type BuildOutput = {
+  /**
+   * Structured diagnostics collected during the build: error/warning/info problems
+   * (each with a code, severity, and where known a JSON-pointer location) plus a
+   * `performance` diagnostic per plugin. Includes a top-level diagnostic when the build
+   * threw before completing. Use {@link Diagnostics.hasError} to test for failure.
+   */
+  diagnostics: Array<Diagnostic>;
+  /**
+   * All files generated during this build.
+   */
+  files: Array<FileNode>;
+  /**
+   * The plugin driver that orchestrated this build.
+   */
+  driver: KubbDriver;
+  /**
+   * The configured `Storage` backend, for reading back a generated file's final content.
+   * Use `files` to list what this build produced.
+   *
+   * @example Read a generated file
+   * `const code = await buildOutput.storage.readItem('/src/gen/pet.ts')`
+   */
+  storage: Storage;
+};
+//#endregion
+//#region src/Diagnostics.d.ts
+/**
+ * How serious a diagnostic is. `error` fails the build, `warning` and `info`
+ * are reported but do not.
+ */
+type DiagnosticSeverity = 'error' | 'warning' | 'info';
+/**
+ * A human-readable explanation of a diagnostic code: a short title, what triggers it, and how
+ * to resolve it. This is the source of truth the kubb.dev `/reference/diagnostics#<slug>` sections mirror, so
+ * every code stays documented in one place. Adding a code without documenting it fails the build.
+ */
+type DiagnosticDoc = {
+  /**
+   * Short title shown as the docs heading.
+   */
+  title: string;
+  /**
+   * What triggers the diagnostic.
+   */
+  cause: string;
+  /**
+   * The action that resolves it.
+   */
+  fix: string;
+};
+/**
+ * Points a diagnostic back into the source document. Inputs are parsed into an
+ * object model with no line/column, so locations carry a JSON pointer the adapter
+ * builds (the OAS adapter emits `#/components/schemas/Pet`). A `config` diagnostic
+ * points at the Kubb config itself and so has no pointer.
+ */
+type DiagnosticLocation = {
+  kind: 'schema';
+  /**
+   * RFC 6901 JSON pointer into the source document.
+   */
+  pointer: string;
+  /**
+   * The original reference when the diagnostic stems from an unresolved one.
+   */
+  ref?: string;
+} | {
+  kind: 'operation' | 'document';
+  /**
+   * RFC 6901 JSON pointer into the source document.
+   */
+  pointer: string;
+} | {
+  kind: 'config';
+};
+/**
+ * What a diagnostic carries.
+ * - `problem` is a build issue shown to the user, and the only kind rendered as a problem.
+ * - `performance` records a plugin's elapsed time.
+ * - `update` is a version notice.
+ */
+type DiagnosticKind = 'problem' | 'performance' | 'update';
+/**
+ * Codes that describe a build problem: every {@link DiagnosticCode} except the
+ * `performance` and `updateAvailable` codes, which ride on their own variants.
+ */
+type ProblemCode = Exclude<DiagnosticCode, typeof diagnosticCode.performance | typeof diagnosticCode.updateAvailable>;
+/**
+ * A build problem collected during a run, gathered into the result instead of
+ * aborting on the first failure.
+ */
+type ProblemDiagnostic = {
+  /**
+   * @default 'problem'
+   */
+  kind?: 'problem';
+  /**
+   * Stable identifier for the problem, from the {@link diagnosticCode} catalog.
+   */
+  code: ProblemCode;
+  severity: DiagnosticSeverity;
+  message: string;
+  location?: DiagnosticLocation;
+  /**
+   * A suggested fix, phrased as an action the user can take.
+   */
+  help?: string;
+  /**
+   * Name of the plugin or subsystem that produced the diagnostic.
+   */
+  plugin?: string;
+  /** Issue tracker URL of the extension that crashed, from its `meta.issues`. */
+  issues?: string;
+  /**
+   * The underlying error, when the diagnostic wraps a thrown one.
+   */
+  cause?: Error;
+};
+/**
+ * A per-plugin performance record, built with {@link Diagnostics.performance}. The `performance`
+ * kind keeps it out of the problem list. It feeds the per-plugin timing bars, and reporters sum
+ * these into the run total.
+ */
+type PerformanceDiagnostic = {
+  kind: 'performance';
+  code: typeof diagnosticCode.performance;
+  severity: 'info';
+  message: string;
+  /**
+   * The plugin this measurement belongs to.
+   */
+  plugin: string;
   /**
-   * The structured diagnostic to render: a build problem or a version-update notice.
+   * Elapsed milliseconds.
    */
-  diagnostic: ProblemDiagnostic | UpdateDiagnostic;
-};
-type KubbGenerationSummaryContext = {
   duration: number;
-  fileCount: number;
-  failedPlugins: number;
-  status: 'success' | 'failed';
 };
-type KubbFilesProcessingStartContext = {
+/**
+ * A notice that a newer Kubb version is available on npm, built with {@link Diagnostics.update}.
+ * It renders like any info diagnostic.
+ */
+type UpdateDiagnostic = {
+  kind: 'update';
+  code: typeof diagnosticCode.updateAvailable;
+  severity: 'info';
+  message: string;
   /**
-   * Files about to be serialized and written.
+   * The running Kubb version.
    */
-  files: Array<FileNode>;
-};
-type KubbFileProcessingUpdate = {
+  currentVersion: string;
   /**
-   * Number of files processed so far in this batch.
+   * The newest version published on npm.
    */
-  processed: number;
+  latestVersion: string;
+};
+/**
+ * A structured record collected during a build, discriminated on `kind`: a
+ * {@link ProblemDiagnostic} for an issue, a {@link PerformanceDiagnostic} for a per-plugin
+ * timing, or an {@link UpdateDiagnostic} for a version notice.
+ */
+type Diagnostic = ProblemDiagnostic | PerformanceDiagnostic | UpdateDiagnostic;
+/**
+ * Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
+ * that lets deep code report a diagnostic without threading a callback.
+ *
+ * The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
+ * `Diagnostics.scope` activates it for a run, so anything inside that run (the
+ * adapter parse, a generator) reports through `Diagnostics.report` and lands
+ * in the same run.
+ */
+declare class Diagnostics {
+  #private;
   /**
-   * Total number of files in this batch.
+   * The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
    */
-  total: number;
+  static code: {
+    readonly unknown: "KUBB_UNKNOWN";
+    readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
+    readonly inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED";
+    readonly inputUnreachable: "KUBB_INPUT_UNREACHABLE";
+    readonly inputRequired: "KUBB_INPUT_REQUIRED";
+    readonly legacyInput: "KUBB_LEGACY_INPUT";
+    readonly invalidDocument: "KUBB_INVALID_DOCUMENT";
+    readonly invalidSpec: "KUBB_INVALID_SPEC";
+    readonly refNotFound: "KUBB_REF_NOT_FOUND";
+    readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
+    readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
+    readonly incompatibleExtension: "KUBB_INCOMPATIBLE_EXTENSION";
+    readonly missingDependency: "KUBB_MISSING_DEPENDENCY";
+    readonly incompatibleDependency: "KUBB_INCOMPATIBLE_DEPENDENCY";
+    readonly pluginFailed: "KUBB_PLUGIN_FAILED";
+    readonly adapterFailed: "KUBB_ADAPTER_FAILED";
+    readonly parserFailed: "KUBB_PARSER_FAILED";
+    readonly pluginWarning: "KUBB_PLUGIN_WARNING";
+    readonly pluginInfo: "KUBB_PLUGIN_INFO";
+    readonly noContext: "KUBB_NO_CONTEXT";
+    readonly unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT";
+    readonly deprecated: "KUBB_DEPRECATED";
+    readonly adapterRequired: "KUBB_ADAPTER_REQUIRED";
+    readonly pathTraversal: "KUBB_PATH_TRAVERSAL";
+    readonly cleanRoot: "KUBB_CLEAN_ROOT";
+    readonly invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS";
+    readonly postGenerateFailed: "KUBB_POST_GENERATE_FAILED";
+    readonly formatFailed: "KUBB_FORMAT_FAILED";
+    readonly lintFailed: "KUBB_LINT_FAILED";
+    readonly barrelDuplicateExport: "KUBB_BARREL_DUPLICATE_EXPORT";
+    readonly internalError: "KUBB_INTERNAL_ERROR";
+    readonly performance: "KUBB_PERFORMANCE";
+    readonly updateAvailable: "KUBB_UPDATE_AVAILABLE";
+  };
   /**
-   * Completion percentage, `0` to `100`.
+   * Type guard for a build {@link ProblemDiagnostic}.
    */
-  percentage: number;
+  static isProblem: (diagnostic: Diagnostic) => diagnostic is ProblemDiagnostic;
   /**
-   * The file that was just processed.
+   * Type guard for a version-update {@link UpdateDiagnostic}.
    */
-  file: FileNode;
+  static isUpdate: (diagnostic: Diagnostic) => diagnostic is UpdateDiagnostic;
   /**
-   * Resolved configuration for this build.
+   * Type guard for a per-plugin {@link PerformanceDiagnostic}.
    */
-  config: Config;
-};
-type KubbFilesProcessingUpdateContext = {
+  static isPerformance: (diagnostic: Diagnostic) => diagnostic is PerformanceDiagnostic;
   /**
-   * All files processed in this flush chunk.
+   * An `Error` that carries a {@link Diagnostic}, so structured problems can flow
+   * through the existing throw/catch paths while keeping their code and location.
+   *
+   * @example
+   * ```ts
+   * throw new Diagnostics.Error({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
+   * ```
    */
-  files: Array<KubbFileProcessingUpdate>;
-};
-type KubbFilesProcessingEndContext = {
+  static Error: {
+    new (diagnostic: ProblemDiagnostic): {
+      diagnostic: ProblemDiagnostic;
+      name: string;
+      message: string;
+      stack?: string;
+      cause?: unknown;
+    };
+    isError(error: unknown): error is Error;
+    isError(value: unknown): value is Error;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+  };
   /**
-   * All files that were serialized in this batch.
+   * Structural check for a {@link Diagnostics.Error}, including one thrown from a duplicated
+   * `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
+   * that carries a `code`.
    */
-  files: Array<FileNode>;
-};
-type KubbHookStartContext = {
+  static isError(error: unknown): error is InstanceType<typeof Diagnostics.Error>;
   /**
-   * Optional identifier for correlating start/end hooks.
+   * Runs `fn` with `sink` as the active diagnostic sink for the whole async
+   * subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
    */
-  id?: string;
+  static scope<T>(sink: (diagnostic: Diagnostic) => void, fn: () => T): T;
   /**
-   * The shell command that is about to run.
+   * Collects a diagnostic into the active build via the run-scoped sink, without throwing.
+   * Returns `true` when a run consumed it, `false` when called outside a {@link Diagnostics.scope}
+   * (so callers can fall back to throwing). Use a `warning`/`info` severity for non-fatal issues.
+   * For rendering a diagnostic live on the hook bus, use {@link Diagnostics.emit} instead.
    */
-  command: string;
+  static report(diagnostic: Diagnostic): boolean;
   /**
-   * Optional label for the command, shown in the CLI output when set.
+   * Emits a diagnostic, or any thrown value, on the run's hooks so the loggers render it live.
+   * A coded problem or an update goes to `kubb:diagnostic`. An uncoded one goes to `kubb:error`
+   * whole, so every wrapper's message, its help, and the stack survive. To collect a diagnostic into
+   * the build result from deep in a run, use {@link Diagnostics.report} instead.
    */
-  name?: string;
+  static emit(hooks: Hookable<KubbHooks>, value: ProblemDiagnostic | UpdateDiagnostic | unknown): Promise<void>;
   /**
-   * Parsed argument list, when available.
+   * Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
+   * keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
    */
-  args?: ReadonlyArray<string>;
-};
-/**
- * Emitted for each line streamed from a hook's stdout while it runs.
- * A logger correlates the line to its active UI element via `id`.
- */
-type KubbHookLineContext = {
+  static from(error: unknown): ProblemDiagnostic;
   /**
-   * Identifier matching the corresponding `kubb:hook:start` hook.
+   * Coerces an error thrown by a plugin, adapter, or parser into a diagnostic attributed to it.
+   * A structured {@link Diagnostics.Error} keeps its code. Any other error is a crash: it gets the
+   * kind's `*_FAILED` code and the extension's `meta.issues` link, so the user reports it to the
+   * extension's maintainers instead of to Kubb.
    */
-  id: string;
+  static fromExtension(error: unknown, { kind, extension }: {
+    kind: ExtensionKind;
+    extension: ExtensionNamed;
+  }): ProblemDiagnostic;
   /**
-   * A single streamed stdout line, without its trailing newline.
+   * Builds a per-plugin performance record. Reporters sum these into the run total.
    */
-  line: string;
-};
-/** Emitted when a hook subprocess ends: its `kubb:hook:start` context plus the outcome. */
-type KubbHookEndContext = KubbHookStartContext & HookResult;
-/**
- * CLI options derived from command-line flags.
- */
-type CLIOptions = {
+  static performance({ plugin, duration }: {
+    plugin: string;
+    duration: number;
+  }): PerformanceDiagnostic;
   /**
-   * Path to the Kubb config file.
+   * Builds the version-update notice shown when a newer Kubb is published on npm.
    */
-  config?: string;
+  static update({ currentVersion, latestVersion }: {
+    currentVersion: string;
+    latestVersion: string;
+  }): UpdateDiagnostic;
   /**
-   * OpenAPI input path or URL passed as the positional argument to `kubb generate`.
-   * Overrides `config.input` when set.
+   * True when any diagnostic is an error, the severity that fails a build. Non-error
+   * diagnostics are ignored.
    */
-  input?: string;
+  static hasError(diagnostics: ReadonlyArray<Diagnostic>): boolean;
   /**
-   * Re-run generation whenever input files change.
+   * Names of the plugins that failed, deduped, derived from the error diagnostics
+   * that carry a `plugin`.
    */
-  watch?: boolean;
+  static failedPlugins(diagnostics: ReadonlyArray<Diagnostic>): Array<string>;
   /**
-   * Controls how much output the CLI prints.
-   *
-   * @default 'info'
+   * Counts `problem` diagnostics by severity for the run summary. `performance` and
+   * `update` diagnostics are ignored.
    */
-  logLevel?: 'silent' | 'info' | 'verbose';
+  static count(diagnostics: ReadonlyArray<Diagnostic>): {
+    errors: number;
+    warnings: number;
+    infos: number;
+  };
   /**
-   * Reporters selected on the CLI via `--reporter`, overriding `config.reporters`.
+   * Drops duplicate `problem` diagnostics that share a code, location pointer, and
+   * plugin, so the same issue reported across several passes is shown once. Non-problem
+   * diagnostics are always kept.
    */
-  reporters?: Array<ReporterName>;
-};
-/**
- * All accepted forms of a Kubb configuration.
- * Accepts `Config`/`Config[]`/promise or a factory (optionally receiving `TCliOptions`).
- */
-type PossibleConfig<TCliOptions = undefined> = PossiblePromise<Config | Array<Config>> | ((...args: [TCliOptions] extends [undefined] ? [] : [TCliOptions]) => PossiblePromise<Config | Array<Config>>);
-/**
- * Full output produced by a successful or failed build.
- */
-type BuildOutput = {
+  static dedupe(diagnostics: ReadonlyArray<Diagnostic>): Array<Diagnostic>;
   /**
-   * Structured diagnostics collected during the build: error/warning/info problems
-   * (each with a code, severity, and where known a JSON-pointer location) plus a
-   * `performance` diagnostic per plugin. Includes a top-level diagnostic when the build
-   * threw before completing. Use {@link Diagnostics.hasError} to test for failure.
+   * Builds the kubb.dev docs URL for a diagnostic code, e.g.
+   * `KUBB_REF_NOT_FOUND` → `https://kubb.dev/docs/5.x/reference/diagnostics#kubb-ref-not-found`.
    */
-  diagnostics: Array<Diagnostic>;
+  static docsUrl(code: string): string;
   /**
-   * All files generated during this build.
+   * The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
+   * `/reference/diagnostics#<slug>` section.
    */
-  files: Array<FileNode>;
+  static explain(code: DiagnosticCode): DiagnosticDoc;
   /**
-   * The plugin driver that orchestrated this build.
+   * Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+   * consumers, with the catalog `title`, `cause`, and fix, and the `cause` error as `causes` and
+   * `stack`. Absent optional fields are omitted.
    */
-  driver: KubbDriver;
+  static serialize: typeof serialize;
   /**
-   * The configured `Storage` backend, for reading back a generated file's final content.
-   * Use `files` to list what this build produced.
-   *
-   * @example Read a generated file
-   * `const code = await buildOutput.storage.readItem('/src/gen/pet.ts')`
+   * Renders a diagnostic as lines for an `agent` (the default) or a `human`. See {@link format}.
    */
-  storage: Storage;
-};
+  static format: typeof format;
+}
 //#endregion
 //#region src/nodeCache.d.ts
 /**
@@ -1927,21 +2044,24 @@ type GeneratorContext<TOptions extends PluginType = PluginType> = {
   resolver: TOptions['resolver'];
   /**
    * Report a warning. Collected as a `warning` diagnostic attributed to the current
-   * plugin. It surfaces in the run summary but does not fail the build. For a structured
-   * diagnostic with a code and source location, use `Diagnostics.report` or throw a
-   * `Diagnostics.Error` directly.
+   * plugin. It surfaces in the run summary but does not fail the build. Pass `options` to set
+   * the `code`, the `help` text, or the source `location`.
+   *
+   * @example
+   * `ctx.warn('Enum has no values', { help: 'Add values to the enum.', location: { kind: 'schema', pointer: '#/components/schemas/Status' } })`
    */
-  warn: (message: string) => void;
+  warn: (message: string, options?: Partial<Pick<ProblemDiagnostic, 'code' | 'help' | 'location'>>) => void;
   /**
    * Report an error. Collected as an `error` diagnostic attributed to the current
-   * plugin, which fails the build.
+   * plugin, which fails the build. A `Diagnostics.Error` keeps its own code, help, and location.
+   * Pass `options` to set them for a plain message or error.
    */
-  error: (error: string | Error) => void;
+  error: (error: string | Error, options?: Partial<Pick<ProblemDiagnostic, 'code' | 'help' | 'location'>>) => void;
   /**
    * Report an informational message. Collected as an `info` diagnostic attributed to
-   * the current plugin.
+   * the current plugin. Pass `options` to set the `code`, the `help` text, or the source `location`.
    */
-  info: (message: string) => void;
+  info: (message: string, options?: Partial<Pick<ProblemDiagnostic, 'code' | 'help' | 'location'>>) => void;
   /**
    * The configured adapter instance.
    */
@@ -2846,7 +2966,7 @@ type ExtensionNamed = {
 /**
  * Returns `meta`, or `{ name }` for an extension that only sets the deprecated `name`. Throws `KUBB_INVALID_PLUGIN_OPTIONS` when it has neither.
  */
-declare function resolveMeta({ name, meta }: ExtensionNamed): ExtensionMeta;
+declare function resolveMeta(extension: ExtensionNamed): ExtensionMeta;
 /**
  * Sets how Kubb checks one entry in a `dependencies` record.
  */
@@ -3024,5 +3144,5 @@ type AdapterFactory<T extends AdapterFactoryOptions = AdapterFactoryOptions> = E
  */
 declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(definition: AdapterDefinition<T>): AdapterFactory<T>;
 //#endregion
-export { NodeCache as $, UpdateDiagnostic as $t, PluginFactory as A, RunHookOptions as At, ResolveImportsOptions as B, UserReporter as Bt, NormalizedPlugin as C, KubbPluginsEndContext as Ct, Override as D, PostGenerateCommand as Dt, OutputOptions as E, PossibleConfig as Et, definePlugin as F, GenerationResult as Ft, ResolverFile as G, DiagnosticKind as Gt, ResolvePathOptions as H, logLevel as Ht, BannerMeta as I, Reporter as It, ResolverPatch as J, Diagnostics as Jt, ResolverFileParams as K, DiagnosticLocation as Kt, ResolveBannerContext as L, ReporterContext as Lt, PluginType as M, KubbDriver as Mt, ResolvePluginOptions as N, Storage as Nt, Plugin as O, UserConfig as Ot, assertPluginOption as P, createStorage as Pt, defineGenerator as Q, SerializedDiagnostic as Qt, ResolveBannerFile as R, ReporterName as Rt, KubbPluginStartContext as S, KubbMessageContext as St, OutputMode as T, KubbWarnContext as Tt, Resolver as U, Diagnostic as Ut, ResolveOptionsContext as V, createReporter as Vt, ResolverDefault as W, DiagnosticDoc as Wt, Generator as X, ProblemCode as Xt, ResolverPathParams as Y, PerformanceDiagnostic as Yt, GeneratorContext as Z, ProblemDiagnostic as Zt, Filter as _, KubbHookLineContext as _t, AdapterSource as a, ParserDefinition as an, KubbBuildEndContext as at, KubbPluginEndContext as b, KubbInfoContext as bt, ExtensionDependency as c, KubbErrorContext as ct, ExtensionKind as d, KubbFilesProcessingStartContext as dt, Hookable as en, BuildOutput as et, ExtensionMeta as f, KubbFilesProcessingUpdateContext as ft, Exclude$1 as g, KubbHookEndContext as gt, resolveMeta as h, KubbGenerationSummaryContext as ht, AdapterFactoryOptions as i, Parser as in, Input as it, PluginName as j, runHook as jt, PluginDefinition as k, HookResult as kt, ExtensionDependencyRecord as l, KubbFileProcessingUpdate as lt, defineExtension as m, KubbGenerationStartContext as mt, AdapterDefinition as n, RendererFactory as nn, Config as nt, createAdapter as o, ParserFactory as on, KubbBuildStartContext as ot, checkCompatibility as p, KubbGenerationEndContext as pt, ResolverFilePathParams as q, DiagnosticSeverity as qt, AdapterFactory as r, createRenderer as rn, FilesContext as rt, ExtensionDependencies as s, defineParser as sn, KubbDiagnosticContext as st, Adapter as t, Renderer as tn, CLIOptions as tt, ExtensionFactory as u, KubbFilesProcessingEndContext as ut, Group as v, KubbHookStartContext as vt, Output as w, KubbSuccessContext as wt, KubbPluginSetupContext as x, KubbLifecycleStartContext as xt, Include as y, KubbHooks as yt, ResolveFileOptions as z, ReporterPluginFiles as zt };
-//# sourceMappingURL=createAdapter-D55JE9lX.d.ts.map
+export { NodeCache as $, ReporterPluginFiles as $t, PluginFactory as A, KubbInfoContext as At, ResolveImportsOptions as B, RunHookOptions as Bt, NormalizedPlugin as C, KubbGenerationEndContext as Ct, Override as D, KubbHookLineContext as Dt, OutputOptions as E, KubbHookEndContext as Et, definePlugin as F, KubbWarnContext as Ft, ResolverFile as G, RendererFactory as Gt, ResolvePathOptions as H, KubbDriver as Ht, BannerMeta as I, PossibleConfig as It, ResolverPatch as J, createStorage as Jt, ResolverFileParams as K, createRenderer as Kt, ResolveBannerContext as L, PostGenerateCommand as Lt, PluginType as M, KubbMessageContext as Mt, ResolvePluginOptions as N, KubbPluginsEndContext as Nt, Plugin as O, KubbHookStartContext as Ot, assertPluginOption as P, KubbSuccessContext as Pt, defineGenerator as Q, ReporterName as Qt, ResolveBannerFile as R, UserConfig as Rt, KubbPluginStartContext as S, KubbFilesProcessingUpdateContext as St, OutputMode as T, KubbGenerationSummaryContext as Tt, Resolver as U, Hookable as Ut, ResolveOptionsContext as V, runHook as Vt, ResolverDefault as W, Renderer as Wt, Generator as X, Reporter as Xt, ResolverPathParams as Y, GenerationResult as Yt, GeneratorContext as Z, ReporterContext as Zt, Filter as _, KubbDiagnosticContext as _t, AdapterSource as a, Parser as an, Diagnostics as at, KubbPluginEndContext as b, KubbFilesProcessingEndContext as bt, ExtensionDependency as c, defineParser as cn, ProblemDiagnostic as ct, ExtensionKind as d, CLIOptions as dt, UserReporter as en, Diagnostic as et, ExtensionMeta as f, Config as ft, Exclude$1 as g, KubbBuildStartContext as gt, resolveMeta as h, KubbBuildEndContext as ht, AdapterFactoryOptions as i, SerializedDiagnostic as in, DiagnosticSeverity as it, PluginName as j, KubbLifecycleStartContext as jt, PluginDefinition as k, KubbHooks as kt, ExtensionDependencyRecord as l, UpdateDiagnostic as lt, defineExtension as m, Input as mt, AdapterDefinition as n, logLevel as nn, DiagnosticKind as nt, createAdapter as o, ParserDefinition as on, PerformanceDiagnostic as ot, checkCompatibility as p, FilesContext as pt, ResolverFilePathParams as q, Storage as qt, AdapterFactory as r, DiagnosticFormatOptions as rn, DiagnosticLocation as rt, ExtensionDependencies as s, ParserFactory as sn, ProblemCode as st, Adapter as t, createReporter as tn, DiagnosticDoc as tt, ExtensionFactory as u, BuildOutput as ut, Group as v, KubbErrorContext as vt, Output as w, KubbGenerationStartContext as wt, KubbPluginSetupContext as x, KubbFilesProcessingStartContext as xt, Include as y, KubbFileProcessingUpdate as yt, ResolveFileOptions as z, HookResult as zt };
+//# sourceMappingURL=createAdapter-CMnLz31B.d.ts.map