@kubb/core 5.0.0-beta.89 → 5.0.0-beta.91

package/dist/{Diagnostics-CM0-Ae30.d.ts → types-aNebW3Ui.d.ts}

@@ -56,7 +56,7 @@ type AdapterFactoryOptions<TName extends string = string, TOptions extends objec
  * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   input: { path: './petStore.yaml' },
+ *   input: './petStore.yaml',
  *   output: { path: './src/gen' },
  *   adapter: adapterOas(),
  *   plugins: [pluginTs()],
@@ -143,7 +143,7 @@ declare const diagnosticCode: {
    */
   readonly unknown: "KUBB_UNKNOWN";
   /**
-   * The `input.path` file or URL could not be read.
+   * The file or URL set as `input` could not be read.
    */
   readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
   /**
@@ -224,6 +224,454 @@ declare const diagnosticCode: {
  */
 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.
+ * Wraps Node's `EventEmitter` with full TypeScript hook-map inference.
+ *
+ * @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;
+  /**
+   * Maximum number of listeners per hook before Node emits a memory-leak warning.
+   * @default 10
+   */
+  constructor(maxListener?: number);
+  /**
+   * Calls `hookName` and awaits all registered listeners sequentially.
+   * Throws if any listener rejects, wrapping the cause with the hook name and serialized arguments.
+   *
+   * @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;
+  /**
+   * Raises or lowers the per-hook listener ceiling before Node warns about a memory leak.
+   * Set this above the expected listener count when many listeners attach by design.
+   *
+   * @example
+   * ```ts
+   * hooks.setMaxListeners(40)
+   * ```
+   */
+  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 `/diagnostics/<slug>` pages 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;
+  /**
+   * 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;
+/**
+ * Maps each {@link DiagnosticCode} to the variant it selects, for {@link narrow}.
+ * Every {@link ProblemCode} selects a {@link ProblemDiagnostic}, and the two bookkeeping codes
+ * select their own variant.
+ */
+type DiagnosticByCode = Record<ProblemCode, ProblemDiagnostic> & Record<typeof diagnosticCode.performance, PerformanceDiagnostic> & Record<typeof diagnosticCode.updateAvailable, UpdateDiagnostic>;
+/**
+ * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+ *
+ * @example
+ * ```ts
+ * const update = narrow(diagnostic, diagnosticCode.updateAvailable)
+ * if (update) {
+ *   console.log(update.latestVersion)
+ * }
+ * ```
+ */
+declare function narrow<C extends DiagnosticCode>(diagnostic: Diagnostic, code: C): DiagnosticByCode[C] | null;
+/**
+ * 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;
+  /**
+   * 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 inputRequired: "KUBB_INPUT_REQUIRED";
+    readonly refNotFound: "KUBB_REF_NOT_FOUND";
+    readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
+    readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
+    readonly pluginFailed: "KUBB_PLUGIN_FAILED";
+    readonly pluginWarning: "KUBB_PLUGIN_WARNING";
+    readonly pluginInfo: "KUBB_PLUGIN_INFO";
+    readonly unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT";
+    readonly deprecated: "KUBB_DEPRECATED";
+    readonly adapterRequired: "KUBB_ADAPTER_REQUIRED";
+    readonly pathTraversal: "KUBB_PATH_TRAVERSAL";
+    readonly invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS";
+    readonly hookFailed: "KUBB_HOOK_FAILED";
+    readonly formatFailed: "KUBB_FORMAT_FAILED";
+    readonly lintFailed: "KUBB_LINT_FAILED";
+    readonly performance: "KUBB_PERFORMANCE";
+    readonly updateAvailable: "KUBB_UPDATE_AVAILABLE";
+  };
+  /**
+   * 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;
+  /**
+   * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+   */
+  static narrow: typeof narrow;
+  /**
+   * 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;
+  };
+  /**
+   * 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;
+  /**
+   * 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.
+   */
+  static hasError(diagnostics: ReadonlyArray<Diagnostic>): boolean;
+  /**
+   * Names of the plugins that failed, deduped, derived from the error diagnostics
+   * that carry a `plugin`.
+   */
+  static failedPlugins(diagnostics: ReadonlyArray<Diagnostic>): Array<string>;
+  /**
+   * Counts `problem` diagnostics by severity for the run summary. `performance` and
+   * `update` diagnostics are ignored.
+   */
+  static count(diagnostics: ReadonlyArray<Diagnostic>): {
+    errors: number;
+    warnings: number;
+    infos: number;
+  };
+  /**
+   * 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.
+   */
+  static dedupe(diagnostics: ReadonlyArray<Diagnostic>): Array<Diagnostic>;
+  /**
+   * 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`.
+   */
+  static docsUrl(code: string): string;
+  /**
+   * The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
+   * `/diagnostics/<slug>` page.
+   */
+  static explain(code: DiagnosticCode): DiagnosticDoc;
+  /**
+   * 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`.
+   */
+  static serialize(diagnostic: Diagnostic): SerializedDiagnostic;
+  /**
+   * 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).
+   *
+   * 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}.
+   */
+  static format(diagnostic: Diagnostic): {
+    headline: string;
+    details: Array<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).
+   */
+  static formatLines(diagnostic: Diagnostic): Array<string>;
+}
+//#endregion
 //#region src/createReporter.d.ts
 /**
  * Numeric log-level thresholds used internally to compare verbosity.
@@ -365,11 +813,6 @@ type Storage = {
    * Removes every entry. Pass `base` to scope the wipe to a key prefix.
    */
   clear(base?: string): Promise<void>;
-  /**
-   * Optional teardown hook for a backend to flush buffers, close connections,
-   * or release file locks.
-   */
-  dispose?(): Promise<void>;
 };
 /**
  * Defines a custom storage backend. The builder receives user options and
@@ -1031,10 +1474,6 @@ type KubbPluginSetupContext<TFactory extends PluginFactoryOptions = PluginFactor
    * generated folder verbatim, instead of building its content from `sources`.
    */
   injectFile(userFileNode: UserFileNode): void;
-  /**
-   * Merge a partial config update into the current build configuration.
-   */
-  updateConfig(config: Partial<Config>): void;
   /**
    * The resolved build configuration at setup time.
    */
@@ -1148,9 +1587,6 @@ type KubbPluginEndContext = {
 declare function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(factory: (options: TFactory['options']) => Plugin<TFactory>): (options?: TFactory['options']) => Plugin<TFactory>;
 //#endregion
 //#region src/defineParser.d.ts
-type PrintOptions = {
-  extname?: FileNode['extname'];
-};
 /**
  * Converts a resolved {@link FileNode} into the final source string that gets
  * written to disk. Kubb ships with TypeScript and TSX parsers. Add your own
@@ -1173,7 +1609,7 @@ type Parser<TMeta extends object = object, TNode = unknown> = {
   /**
    * Serialize the file's AST into source code.
    */
-  parse(file: FileNode<TMeta>, options?: PrintOptions): string;
+  parse(file: FileNode<TMeta>): string;
   /**
    * Render compiler AST nodes for this parser's language into source text.
    * Plugins call this to format the nodes they assemble before handing them
@@ -1182,124 +1618,33 @@ type Parser<TMeta extends object = object, TNode = unknown> = {
   print(...nodes: Array<TNode>): string;
 };
 /**
- * Defines a parser with type-safe `this`. Used to register handlers for new
- * file extensions or to plug a non-TypeScript output into the build.
+ * Wraps a parser factory and returns a function that accepts user options and
+ * yields a typed {@link Parser}. Mirrors {@link definePlugin}: the factory
+ * receives the caller's options, and calling the returned function without
+ * options passes an empty object.
+ *
+ * Register the result in the `parsers` array on `defineConfig`, calling it to
+ * apply options (`parserTs({ extension: { '.ts': '.js' } })`).
  *
  * @example
  * ```ts
  * import { defineParser } from '@kubb/core'
  * import { extractStringsFromNodes } from '@kubb/ast'
  *
- * export const jsonParser = defineParser({
+ * export const parserJson = defineParser((options: { pretty?: boolean } = {}) => ({
  *   name: 'json',
  *   extNames: ['.json'],
  *   parse(file) {
- *     return file.sources
- *       .map((source) => extractStringsFromNodes(source.nodes ?? []))
- *       .join('\n')
+ *     const source = file.sources.map((source) => extractStringsFromNodes(source.nodes ?? [])).join('\n')
+ *     return options.pretty ? JSON.stringify(JSON.parse(source), null, 2) : source
  *   },
  *   print(...nodes) {
  *     return nodes.map(String).join('\n')
  *   },
- * })
- * ```
- */
-declare function defineParser<T extends Parser>(parser: T): T;
-//#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.
- * Wraps Node's `EventEmitter` with full TypeScript hook-map inference.
- *
- * @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;
-  /**
-   * Maximum number of listeners per hook before Node emits a memory-leak warning.
-   * @default 10
-   */
-  constructor(maxListener?: number);
-  /**
-   * Calls `hookName` and awaits all registered listeners sequentially.
-   * Throws if any listener rejects, wrapping the cause with the hook name and serialized arguments.
-   *
-   * @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;
-  /**
-   * Raises or lowers the per-hook listener ceiling before Node warns about a memory leak.
-   * Set this above the expected listener count when many listeners attach by design.
-   *
-   * @example
-   * ```ts
-   * hooks.setMaxListeners(40)
-   * ```
-   */
-  setMaxListeners(max: number): void;
-  /**
-   * Removes all listeners from every hook channel.
-   *
-   * @example
-   * ```ts
-   * hooks.removeAllHooks()
-   * ```
-   */
-  removeAllHooks(): void;
-}
+declare function defineParser<TOptions extends object = object, TMeta extends object = object, TNode = unknown>(factory: (options: TOptions) => Parser<TMeta, TNode>): (options?: TOptions) => Parser<TMeta, TNode>;
 //#endregion
 //#region src/FileManager.d.ts
 /**
@@ -1318,7 +1663,6 @@ type FileManagerHooks = {
 };
 type ParseOptions = {
   parsers?: Map<FileNode['extname'], Parser>;
-  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
 };
 type WriteOptions = ParseOptions & {
   storage: Storage;
@@ -1357,8 +1701,7 @@ declare class FileManager {
    * Converts a file's AST sources (or its `copy` source) into the final on-disk string.
    */
   parse(file: FileNode, {
-    parsers,
-    extension
+    parsers
   }?: ParseOptions): Promise<string>;
   /**
    * Converts and writes every file at once, letting `storage.setItem` decide how much of
@@ -1366,8 +1709,7 @@ declare class FileManager {
    */
   write(files: Array<FileNode>, {
     storage,
-    parsers,
-    extension
+    parsers
   }: WriteOptions): Promise<void>;
 }
 //#endregion
@@ -1750,7 +2092,7 @@ declare class Kubb$1 {
  * import { pluginTs } from '@kubb/plugin-ts'
  *
  * const kubb = createKubb({
- *   input: { path: './petStore.yaml' },
+ *   input: './petStore.yaml',
  *   output: { path: './src/gen' },
  *   adapter: adapterOas(),
  *   plugins: [pluginTs()],
@@ -1767,38 +2109,22 @@ declare function createKubb(userConfig: UserConfig, options?: CreateKubbOptions)
  */
 type ExtractRegistryKey<T, K extends PropertyKey> = K extends keyof T ? T[K] : {};
 /**
- * Path to an input file to generate from, absolute or relative to the config file. The adapter
- * parses it (e.g. an OpenAPI YAML or JSON spec) into the universal AST.
- */
-type InputPath = {
-  /**
-   * Path to your Swagger/OpenAPI file, absolute or relative to the config file location.
-   *
-   * @example
-   * ```ts
-   * { path: './petstore.yaml' }
-   * { path: '/absolute/path/to/openapi.json' }
-   * ```
-   */
-  path: string;
-};
-/**
- * Inline spec to generate from, passed directly instead of read from a file. A string
- * (YAML/JSON) or a parsed object.
+ * Source to generate from. Kubb detects what it was given:
+ *
+ * - A string that is a local file path (absolute or relative to the config file) or a URL is
+ *   read and parsed by the adapter (e.g. an OpenAPI YAML or JSON spec).
+ * - A string that is inline OpenAPI content (JSON or YAML) is parsed directly.
+ * - A parsed object is used as-is, without touching the filesystem.
+ *
+ * @example
+ * ```ts
+ * './petstore.yaml'                       // local path
+ * 'https://example.com/openapi.json'      // URL
+ * '{ "openapi": "3.1.0", "info": {...} }' // inline JSON
+ * { openapi: '3.1.0', info: { ... } }     // parsed object
+ * ```
  */
-type InputData = {
-  /**
-   * Swagger/OpenAPI data as a string (YAML/JSON) or a parsed object.
-   *
-   * @example
-   * ```ts
-   * { data: fs.readFileSync('./openapi.yaml', 'utf8') }
-   * { data: { openapi: '3.1.0', info: { ... } } }
-   * ```
-   */
-  data: string | unknown;
-};
-type Input = InputPath | InputData;
+type Input = string | Record<string, unknown>;
 /**
  * Resolved build configuration for a Kubb run: what to generate from (adapter, input), where to
  * write it (output), how (plugins), and the runtime pieces (parsers, storage). See
@@ -1828,7 +2154,7 @@ type Config<TInput = Input> = {
    * set of file extensions, and a fallback parser handles anything else.
    *
    * Already resolved on the `Config` instance (see `UserConfig` for the
-   * optional form that defaults to `[parserTs, parserTsx, parserMd]`).
+   * optional form that defaults to `[parserTs(), parserTsx(), parserMd()]`).
    *
    * @example
    * ```ts
@@ -1836,7 +2162,7 @@ type Config<TInput = Input> = {
    * import { parserTs, parserTsx } from '@kubb/parser-ts'
    *
    * export default defineConfig({
-   *   parsers: [parserTs, parserTsx],
+   *   parsers: [parserTs(), parserTsx()],
    * })
    * ```
    */
@@ -1854,14 +2180,14 @@ type Config<TInput = Input> = {
    * import { adapterOas } from '@kubb/adapter-oas'
    * export default defineConfig({
    *   adapter: adapterOas(),
-   *   input: { path: './petstore.yaml' },
+   *   input: './petstore.yaml',
    * })
    * ```
    */
   adapter?: Adapter;
   /**
-   * Source file or data to generate code from.
-   * Use `input.path` for a file path or `input.data` for inline data.
+   * Source to generate code from: a local file path, a URL, inline OpenAPI content
+   * (JSON or YAML string), or a parsed spec object. Kubb detects which one it was given.
    * Required when an adapter is configured. Omit it when running in plugin-only mode.
    */
   input?: TInput;
@@ -1912,18 +2238,6 @@ type Config<TInput = Input> = {
      * ```
      */
     lint?: 'auto' | 'eslint' | 'biome' | 'oxlint' | false;
-    /**
-     * Rewrite import extensions in generated files, e.g. emit `.js` imports from `.ts` sources for
-     * ESM dual packages. Keys are the source extension, values the output, and `''` drops it.
-     *
-     * @default { '.ts': '.ts' }
-     * @example
-     * ```ts
-     * extension: { '.ts': '.js' }      // generates import './api.js' instead of './api.ts'
-     * extension: { '.ts': '', '.tsx': '.jsx' }
-     * ```
-     */
-    extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
     /**
      * Banner prepended to every generated file. `'simple'` is the basic Kubb notice, `'full'` adds
      * source, title, description, and API version, and `false` omits it.
@@ -2032,7 +2346,7 @@ type Config<TInput = Input> = {
  * @example
  * ```ts
  * export default defineConfig({
- *   input: { path: './petstore.yaml' },
+ *   input: './petstore.yaml',
  *   output: { path: './src/gen' },
  *   plugins: [pluginTs(), pluginZod()],
  * })
@@ -2046,7 +2360,7 @@ type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'par
   root?: string;
   /**
    * Custom parsers that convert generated AST nodes to strings (TypeScript, JSON, markdown, etc.).
-   * @default [parserTs, parserTsx, parserMd]  // applied by `defineConfig` from the `kubb` package
+   * @default [parserTs(), parserTsx(), parserMd()]  // applied by `defineConfig` from the `kubb` package
    */
   parsers?: Array<Parser>;
   /**
@@ -2190,665 +2504,312 @@ type KubbBuildStartContext = {
    */
   adapter: Adapter;
   /**
-   * Metadata about the parsed document (title, version, base URL, circular schema names, enum names).
-   * To observe individual schemas and operations use the `kubb:generate:schema` / `kubb:generate:operation` hooks.
-   */
-  meta: InputMeta | undefined;
-  /**
-   * Looks up a registered plugin by name, typed by the plugin registry.
-   */
-  getPlugin<TName extends keyof Kubb.PluginRegistry>(name: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
-  getPlugin(name: string): Plugin | undefined;
-  /**
-   * Snapshot of all files accumulated so far.
-   */
-  readonly files: ReadonlyArray<FileNode>;
-  /**
-   * Adds or merges one or more files into the file manager.
-   */
-  upsertFile: (...files: Array<FileNode>) => void;
-};
-type KubbPluginsEndContext = {
-  /**
-   * Resolved configuration for this build.
-   */
-  config: Config;
-  /**
-   * Snapshot of all files accumulated across all plugins.
-   */
-  readonly files: ReadonlyArray<FileNode>;
-  /**
-   * Adds or merges one or more files into the file manager.
-   */
-  upsertFile: (...files: Array<FileNode>) => void;
-};
-type KubbBuildEndContext = {
-  /**
-   * All files generated during this build.
-   */
-  files: Array<FileNode>;
-  /**
-   * Resolved configuration for this build.
-   */
-  config: Config;
-  /**
-   * Absolute path to the output directory.
-   */
-  outputDir: string;
-};
-type KubbLifecycleStartContext = {
-  /**
-   * Current Kubb version string.
-   */
-  version: string;
-};
-type KubbGenerationStartContext = {
-  /**
-   * Resolved configuration for this generation run.
-   */
-  config: Config;
-};
-type KubbGenerationEndContext = {
-  /**
-   * Resolved configuration for this generation run.
-   */
-  config: Config;
-  /**
-   * Read-only view of the files written during this build.
-   * Reads go directly to `config.storage`, nothing extra is held in memory.
-   *
-   * @example Read a generated file
-   * `const code = await storage.getItem('/src/gen/pet.ts')`
-   *
-   * @example Walk every generated file
-   * ```ts
-   * for (const path of await storage.getKeys()) {
-   *   const code = await storage.getItem(path)
-   * }
-   * ```
-   */
-  storage: Storage;
-  /**
-   * Diagnostics collected during the build: error/warning/info problems plus a
-   * `performance` diagnostic per plugin. The end-of-run summary derives its failure counts
-   * and per-plugin timings from these. Set by the CLI runner, omitted by other callers.
-   */
-  diagnostics?: Array<Diagnostic>;
-  /**
-   * `'success'` when all plugins completed without errors, `'failed'` otherwise.
-   */
-  status?: 'success' | 'failed';
-  /**
-   * High-resolution start time from `process.hrtime()`, used to compute the elapsed time.
-   */
-  hrStart?: [number, number];
-  /**
-   * Total number of files created during this run.
-   */
-  filesCreated?: number;
-};
-type KubbInfoContext = {
-  /**
-   * Human-readable info message.
-   */
-  message: string;
-  /**
-   * Optional supplementary detail.
-   */
-  info?: string;
-};
-type KubbErrorContext = {
-  /**
-   * The caught error.
-   */
-  error: Error;
-  /**
-   * Optional structured metadata for additional context.
-   */
-  meta?: Record<string, unknown>;
-};
-type KubbSuccessContext = {
-  /**
-   * Human-readable success message.
-   */
-  message: string;
-  /**
-   * Optional supplementary detail.
-   */
-  info?: string;
-};
-type KubbWarnContext = {
-  /**
-   * Human-readable warning message.
-   */
-  message: string;
-  /**
-   * Optional supplementary detail.
-   */
-  info?: string;
-};
-type KubbDiagnosticContext = {
-  /**
-   * The structured diagnostic to render: a build problem or a version-update notice.
-   */
-  diagnostic: ProblemDiagnostic | UpdateDiagnostic;
-};
-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;
-  /**
-   * Serialized file content, or `undefined` when the file produced no output.
-   */
-  source?: string;
-  /**
-   * 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;
-  /**
-   * 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;
-};
-type KubbHookEndContext = {
-  /**
-   * Optional identifier matching the corresponding `kubb:hook:start` hook.
-   */
-  id?: string;
-  /**
-   * The shell command that ran.
-   */
-  command: string;
-  /**
-   * Parsed argument list, when available.
-   */
-  args?: ReadonlyArray<string>;
-  /**
-   * `true` when the command exited with code `0`.
-   */
-  success: boolean;
-  /**
-   * Error thrown by the command, or `null` on success.
-   */
-  error: Error | null;
-  /**
-   * Captured stdout from the process, populated when it exits non-zero.
-   */
-  stdout?: string;
-  /**
-   * Captured stderr from the process, populated when it exits non-zero.
+   * Metadata about the parsed document (title, version, base URL, circular schema names, enum names).
+   * To observe individual schemas and operations use the `kubb:generate:schema` / `kubb:generate:operation` hooks.
    */
-  stderr?: string;
-};
-/**
- * CLI options derived from command-line flags.
- */
-type CLIOptions = {
+  meta: InputMeta | undefined;
   /**
-   * Path to the Kubb config file.
+   * Looks up a registered plugin by name, typed by the plugin registry.
    */
-  config?: string;
+  getPlugin<TName extends keyof Kubb.PluginRegistry>(name: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
+  getPlugin(name: string): Plugin | undefined;
   /**
-   * OpenAPI input path passed as the positional argument to `kubb generate`.
-   * Overrides `config.input.path` when set.
+   * Snapshot of all files accumulated so far.
    */
-  input?: string;
+  readonly files: ReadonlyArray<FileNode>;
   /**
-   * Re-run generation whenever input files change.
+   * Adds or merges one or more files into the file manager.
    */
-  watch?: boolean;
+  upsertFile: (...files: Array<FileNode>) => void;
+};
+type KubbPluginsEndContext = {
   /**
-   * Controls how much output the CLI prints.
-   *
-   * @default 'info'
+   * Resolved configuration for this build.
    */
-  logLevel?: 'silent' | 'info' | 'verbose';
+  config: Config;
   /**
-   * Reporters selected on the CLI via `--reporter`, overriding `config.reporters`.
+   * Snapshot of all files accumulated across all plugins.
    */
-  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 = {
+  readonly files: ReadonlyArray<FileNode>;
   /**
-   * 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.
+   * Adds or merges one or more files into the file manager.
    */
-  diagnostics: Array<Diagnostic>;
+  upsertFile: (...files: Array<FileNode>) => void;
+};
+type KubbBuildEndContext = {
   /**
    * All files generated during this build.
    */
   files: Array<FileNode>;
   /**
-   * The plugin driver that orchestrated this build.
+   * Resolved configuration for this build.
    */
-  driver: KubbDriver;
+  config: Config;
   /**
-   * 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.getItem('/src/gen/pet.ts')`
+   * Absolute path to the output directory.
    */
-  storage: Storage;
+  outputDir: string;
 };
-//#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 `/diagnostics/<slug>` pages mirror, so
- * every code stays documented in one place. Adding a code without documenting it fails the build.
- */
-type DiagnosticDoc = {
+type KubbLifecycleStartContext = {
   /**
-   * Short title shown as the docs heading.
+   * Current Kubb version string.
    */
-  title: string;
+  version: string;
+};
+type KubbGenerationStartContext = {
   /**
-   * What triggers the diagnostic.
+   * Resolved configuration for this generation run.
    */
-  cause: string;
+  config: Config;
+};
+type KubbGenerationEndContext = {
   /**
-   * The action that resolves it.
+   * Resolved configuration for this generation run.
    */
-  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';
+  config: Config;
   /**
-   * RFC 6901 JSON pointer into the source document.
+   * Read-only view of the files written during this build.
+   * Reads go directly to `config.storage`, nothing extra is held in memory.
+   *
+   * @example Read a generated file
+   * `const code = await storage.getItem('/src/gen/pet.ts')`
+   *
+   * @example Walk every generated file
+   * ```ts
+   * for (const path of await storage.getKeys()) {
+   *   const code = await storage.getItem(path)
+   * }
+   * ```
    */
-  pointer: string;
+  storage: Storage;
   /**
-   * The original reference when the diagnostic stems from an unresolved one.
+   * Diagnostics collected during the build: error/warning/info problems plus a
+   * `performance` diagnostic per plugin. The end-of-run summary derives its failure counts
+   * and per-plugin timings from these. Set by the CLI runner, omitted by other callers.
    */
-  ref?: string;
-} | {
-  kind: 'operation' | 'document';
+  diagnostics?: Array<Diagnostic>;
   /**
-   * RFC 6901 JSON pointer into the source document.
+   * `'success'` when all plugins completed without errors, `'failed'` otherwise.
    */
-  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 = {
+  status?: 'success' | 'failed';
   /**
-   * @default 'problem'
+   * High-resolution start time from `process.hrtime()`, used to compute the elapsed time.
    */
-  kind?: 'problem';
+  hrStart?: [number, number];
   /**
-   * Stable identifier for the problem, from the {@link diagnosticCode} catalog.
+   * Total number of files created during this run.
+   */
+  filesCreated?: number;
+};
+type KubbInfoContext = {
+  /**
+   * Human-readable info message.
    */
-  code: ProblemCode;
-  severity: DiagnosticSeverity;
   message: string;
-  location?: DiagnosticLocation;
   /**
-   * A suggested fix, phrased as an action the user can take.
+   * Optional supplementary detail.
    */
-  help?: string;
+  info?: string;
+};
+type KubbErrorContext = {
   /**
-   * Name of the plugin or subsystem that produced the diagnostic.
+   * The caught error.
    */
-  plugin?: string;
+  error: Error;
   /**
-   * The underlying error, when the diagnostic wraps a thrown one.
+   * Optional structured metadata for additional context.
    */
-  cause?: Error;
+  meta?: Record<string, unknown>;
 };
-/**
- * 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;
+type KubbSuccessContext = {
   /**
-   * The plugin this measurement belongs to.
+   * Human-readable success message.
    */
-  plugin: string;
+  message: string;
   /**
-   * Elapsed milliseconds.
+   * Optional supplementary detail.
    */
-  duration: number;
+  info?: string;
 };
-/**
- * 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;
+type KubbWarnContext = {
   /**
-   * The running Kubb version.
+   * Human-readable warning message.
    */
-  currentVersion: string;
+  message: string;
   /**
-   * The newest version published on npm.
+   * Optional supplementary detail.
    */
-  latestVersion: string;
+  info?: 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;
-/**
- * Maps each {@link DiagnosticCode} to the variant it selects, for {@link narrow}.
- * Every {@link ProblemCode} selects a {@link ProblemDiagnostic}, and the two bookkeeping codes
- * select their own variant.
- */
-type DiagnosticByCode = Record<ProblemCode, ProblemDiagnostic> & Record<typeof diagnosticCode.performance, PerformanceDiagnostic> & Record<typeof diagnosticCode.updateAvailable, UpdateDiagnostic>;
-/**
- * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
- *
- * @example
- * ```ts
- * const update = narrow(diagnostic, diagnosticCode.updateAvailable)
- * if (update) {
- *   console.log(update.latestVersion)
- * }
- * ```
- */
-declare function narrow<C extends DiagnosticCode>(diagnostic: Diagnostic, code: C): DiagnosticByCode[C] | null;
-/**
- * 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;
+type KubbDiagnosticContext = {
+  /**
+   * The structured diagnostic to render: a build problem or a version-update notice.
+   */
+  diagnostic: ProblemDiagnostic | UpdateDiagnostic;
+};
+type KubbFilesProcessingStartContext = {
   /**
-   * The kubb.dev docs link for the code, omitted for the unknown fallback.
+   * Files about to be serialized and written.
    */
-  docsUrl?: string;
+  files: Array<FileNode>;
 };
-/**
- * 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;
+type KubbFileProcessingUpdate = {
   /**
-   * The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
+   * Number of files processed so far in this batch.
    */
-  static code: {
-    readonly unknown: "KUBB_UNKNOWN";
-    readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
-    readonly inputRequired: "KUBB_INPUT_REQUIRED";
-    readonly refNotFound: "KUBB_REF_NOT_FOUND";
-    readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
-    readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
-    readonly pluginFailed: "KUBB_PLUGIN_FAILED";
-    readonly pluginWarning: "KUBB_PLUGIN_WARNING";
-    readonly pluginInfo: "KUBB_PLUGIN_INFO";
-    readonly unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT";
-    readonly deprecated: "KUBB_DEPRECATED";
-    readonly adapterRequired: "KUBB_ADAPTER_REQUIRED";
-    readonly pathTraversal: "KUBB_PATH_TRAVERSAL";
-    readonly invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS";
-    readonly hookFailed: "KUBB_HOOK_FAILED";
-    readonly formatFailed: "KUBB_FORMAT_FAILED";
-    readonly lintFailed: "KUBB_LINT_FAILED";
-    readonly performance: "KUBB_PERFORMANCE";
-    readonly updateAvailable: "KUBB_UPDATE_AVAILABLE";
-  };
+  processed: number;
   /**
-   * Type guard for a build {@link ProblemDiagnostic}.
+   * Total number of files in this batch.
    */
-  static isProblem: (diagnostic: Diagnostic) => diagnostic is ProblemDiagnostic;
+  total: number;
   /**
-   * Type guard for a version-update {@link UpdateDiagnostic}.
+   * Completion percentage, `0` to `100`.
    */
-  static isUpdate: (diagnostic: Diagnostic) => diagnostic is UpdateDiagnostic;
+  percentage: number;
   /**
-   * Type guard for a per-plugin {@link PerformanceDiagnostic}.
+   * Serialized file content, or `undefined` when the file produced no output.
    */
-  static isPerformance: (diagnostic: Diagnostic) => diagnostic is PerformanceDiagnostic;
+  source?: string;
   /**
-   * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+   * The file that was just processed.
    */
-  static narrow: typeof narrow;
+  file: FileNode;
   /**
-   * 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 } })
-   * ```
+   * Resolved configuration for this build.
    */
-  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;
-  };
+  config: Config;
+};
+type KubbFilesProcessingUpdateContext = {
   /**
-   * 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`.
+   * All files processed in this flush chunk.
    */
-  static isError(error: unknown): error is InstanceType<typeof Diagnostics.Error>;
+  files: Array<KubbFileProcessingUpdate>;
+};
+type KubbFilesProcessingEndContext = {
   /**
-   * Runs `fn` with `sink` as the active diagnostic sink for the whole async
-   * subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
+   * All files that were serialized in this batch.
    */
-  static scope<T>(sink: (diagnostic: Diagnostic) => void, fn: () => T): T;
+  files: Array<FileNode>;
+};
+type KubbHookStartContext = {
   /**
-   * 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.
+   * Optional identifier for correlating start/end hooks.
    */
-  static report(diagnostic: Diagnostic): boolean;
+  id?: string;
   /**
-   * 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.
+   * The shell command that is about to run.
    */
-  static emit(hooks: Hookable<KubbHooks>, diagnostic: ProblemDiagnostic | UpdateDiagnostic): Promise<void>;
+  command: string;
   /**
-   * Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
-   * keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
+   * Parsed argument list, when available.
    */
-  static from(error: unknown): ProblemDiagnostic;
+  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 = {
   /**
-   * Builds a per-plugin performance record. Reporters sum these into the run total.
+   * Identifier matching the corresponding `kubb:hook:start` hook.
    */
-  static performance({
-    plugin,
-    duration
-  }: {
-    plugin: string;
-    duration: number;
-  }): PerformanceDiagnostic;
+  id: string;
   /**
-   * Builds the version-update notice shown when a newer Kubb is published on npm.
+   * A single streamed stdout line, without its trailing newline.
    */
-  static update({
-    currentVersion,
-    latestVersion
-  }: {
-    currentVersion: string;
-    latestVersion: string;
-  }): UpdateDiagnostic;
+  line: string;
+};
+type KubbHookEndContext = {
   /**
-   * True when any diagnostic is an error, the severity that fails a build. Non-error
-   * diagnostics are ignored.
+   * Optional identifier matching the corresponding `kubb:hook:start` hook.
    */
-  static hasError(diagnostics: ReadonlyArray<Diagnostic>): boolean;
+  id?: string;
   /**
-   * Names of the plugins that failed, deduped, derived from the error diagnostics
-   * that carry a `plugin`.
+   * The shell command that ran.
    */
-  static failedPlugins(diagnostics: ReadonlyArray<Diagnostic>): Array<string>;
+  command: string;
   /**
-   * Counts `problem` diagnostics by severity for the run summary. `performance` and
-   * `update` diagnostics are ignored.
+   * Parsed argument list, when available.
    */
-  static count(diagnostics: ReadonlyArray<Diagnostic>): {
-    errors: number;
-    warnings: number;
-    infos: number;
-  };
+  args?: ReadonlyArray<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.
+   * `true` when the command exited with code `0`.
    */
-  static dedupe(diagnostics: ReadonlyArray<Diagnostic>): Array<Diagnostic>;
+  success: boolean;
   /**
-   * 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`.
+   * Error thrown by the command, or `null` on success.
    */
-  static docsUrl(code: string): string;
+  error: Error | null;
   /**
-   * The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
-   * `/diagnostics/<slug>` page.
+   * Captured stdout from the process, populated when it exits non-zero.
    */
-  static explain(code: DiagnosticCode): DiagnosticDoc;
+  stdout?: 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`.
+   * Captured stderr from the process, populated when it exits non-zero.
    */
-  static serialize(diagnostic: Diagnostic): SerializedDiagnostic;
+  stderr?: string;
+};
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
   /**
-   * 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).
+   * 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.
    *
-   * 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}.
+   * @default 'info'
    */
-  static format(diagnostic: Diagnostic): {
-    headline: string;
-    details: Array<string>;
-  };
+  logLevel?: 'silent' | 'info' | 'verbose';
   /**
-   * 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).
+   * Reporters selected on the CLI via `--reporter`, overriding `config.reporters`.
    */
-  static formatLines(diagnostic: Diagnostic): Array<string>;
-}
+  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.getItem('/src/gen/pet.ts')`
+   */
+  storage: Storage;
+};
 //#endregion
-export { Include as $, KubbHookStartContext as A, Reporter as At, Kubb$1 as B, KubbFilesProcessingEndContext as C, ResolverPathParams as Ct, KubbGenerationStartContext as D, Storage as Dt, KubbGenerationEndContext as E, createRenderer as Et, KubbSuccessContext as F, logLevel as Ft, KubbDriver as G, Generator as H, KubbWarnContext as I, Adapter as It, Parser as J, FileManagerHooks as K, PossibleConfig as L, AdapterFactoryOptions as Lt, KubbInfoContext as M, ReporterName as Mt, KubbLifecycleStartContext as N, UserReporter as Nt, KubbHookEndContext as O, createStorage as Ot, KubbPluginsEndContext as P, createReporter as Pt, Group as Q, UserConfig as R, AdapterSource as Rt, KubbFileProcessingUpdate as S, ResolverPatch as St, KubbFilesProcessingUpdateContext as T, RendererFactory as Tt, GeneratorContext as U, createKubb as V, defineGenerator as W, Exclude$1 as X, defineParser as Y, Filter as Z, InputPath as _, Resolver as _t, DiagnosticLocation as a, OutputMode as at, KubbDiagnosticContext as b, ResolverFileParams as bt, PerformanceDiagnostic as c, Plugin as ct, SerializedDiagnostic as d, BannerMeta as dt, KubbPluginEndContext as et, UpdateDiagnostic as f, ResolveBannerContext as ft, InputData as g, ResolvePathOptions as gt, Config as h, ResolveOptionsContext as ht, DiagnosticKind as i, Output as it, KubbHooks as j, ReporterContext as jt, KubbHookLineContext as k, GenerationResult as kt, ProblemCode as l, PluginFactoryOptions as lt, CLIOptions as m, ResolveFileOptions as mt, DiagnosticByCode as n, KubbPluginStartContext as nt, DiagnosticSeverity as o, OutputOptions as ot, BuildOutput as p, ResolveBannerFile as pt, Hookable as q, DiagnosticDoc as r, NormalizedPlugin as rt, Diagnostics as s, Override as st, Diagnostic as t, KubbPluginSetupContext as tt, ProblemDiagnostic as u, definePlugin as ut, KubbBuildEndContext as v, ResolverDefault as vt, KubbFilesProcessingStartContext as w, Renderer as wt, KubbErrorContext as x, ResolverFilePathParams as xt, KubbBuildStartContext as y, ResolverFile as yt, CreateKubbOptions as z, createAdapter as zt };
-//# sourceMappingURL=Diagnostics-CM0-Ae30.d.ts.map
+export { ResolveBannerFile as $, GeneratorContext as A, ProblemCode as At, KubbPluginEndContext as B, KubbWarnContext as C, DiagnosticByCode as Ct, Kubb$1 as D, DiagnosticSeverity as Dt, CreateKubbOptions as E, DiagnosticLocation as Et, defineParser as F, Adapter as Ft, OutputMode as G, KubbPluginStartContext as H, Exclude$1 as I, AdapterFactoryOptions as It, Plugin as J, OutputOptions as K, Filter as L, AdapterSource as Lt, KubbDriver as M, SerializedDiagnostic as Mt, FileManagerHooks as N, UpdateDiagnostic as Nt, createKubb as O, Diagnostics as Ot, Parser as P, Hookable as Pt, ResolveBannerContext as Q, Group as R, createAdapter as Rt, KubbSuccessContext as S, Diagnostic as St, UserConfig as T, DiagnosticKind as Tt, NormalizedPlugin as U, KubbPluginSetupContext as V, Output as W, definePlugin as X, PluginFactoryOptions as Y, BannerMeta as Z, KubbHookStartContext as _, ReporterContext as _t, KubbBuildEndContext as a, ResolverFile as at, KubbLifecycleStartContext as b, createReporter as bt, KubbErrorContext as c, ResolverPatch as ct, KubbFilesProcessingStartContext as d, RendererFactory as dt, ResolveFileOptions as et, KubbFilesProcessingUpdateContext as f, createRenderer as ft, KubbHookLineContext as g, Reporter as gt, KubbHookEndContext as h, GenerationResult as ht, Input as i, ResolverDefault as it, defineGenerator as j, ProblemDiagnostic as jt, Generator as k, PerformanceDiagnostic as kt, KubbFileProcessingUpdate as l, ResolverPathParams as lt, KubbGenerationStartContext as m, createStorage as mt, CLIOptions as n, ResolvePathOptions as nt, KubbBuildStartContext as o, ResolverFileParams as ot, KubbGenerationEndContext as p, Storage as pt, Override as q, Config as r, Resolver as rt, KubbDiagnosticContext as s, ResolverFilePathParams as st, BuildOutput as t, ResolveOptionsContext as tt, KubbFilesProcessingEndContext as u, Renderer as ut, KubbHooks as v, ReporterName as vt, PossibleConfig as w, DiagnosticDoc as wt, KubbPluginsEndContext as x, logLevel as xt, KubbInfoContext as y, UserReporter as yt, Include as z };
+//# sourceMappingURL=types-aNebW3Ui.d.ts.map