@kubb/core 5.0.0-beta.37 → 5.0.0-beta.39

package/dist/{diagnostics-B0ONXReg.d.ts → diagnostics-DhfW8YpT.d.ts}

@@ -108,115 +108,6 @@ declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[
  */
 type PossiblePromise<T> = Promise<T> | T;
 //#endregion
-//#region src/constants.d.ts
-/**
- * Base URL for the Kubb Studio web app.
- */
-declare const DEFAULT_STUDIO_URL: "https://kubb.studio";
-/**
- * Numeric log-level thresholds used internally to compare verbosity.
- *
- * Higher numbers are more verbose.
- */
-declare const logLevel: {
-  readonly silent: number;
-  readonly error: 0;
-  readonly warn: 1;
-  readonly info: 3;
-  readonly verbose: 4;
-};
-/**
- * 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 `input.path` file or URL could not be read.
-   */
-  readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
-  /**
-   * An adapter was configured without an `input`.
-   */
-  readonly inputRequired: "KUBB_INPUT_REQUIRED";
-  /**
-   * 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";
-  /**
-   * A plugin threw while generating.
-   */
-  readonly pluginFailed: "KUBB_PLUGIN_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 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";
-  /**
-   * The `devtools` config is set to something other than an object.
-   */
-  readonly devtoolsInvalid: "KUBB_DEVTOOLS_INVALID";
-  /**
-   * 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";
-  /**
-   * A post-generate shell hook (`hooks.done`) exited with a failure.
-   */
-  readonly hookFailed: "KUBB_HOOK_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";
-  /**
-   * 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/createAdapter.d.ts
 /**
  * Source data handed to an adapter's `parse` function. Mirrors the config
@@ -347,6 +238,95 @@ type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) =
  */
 declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
 //#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 `input.path` file or URL could not be read.
+   */
+  readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
+  /**
+   * An adapter was configured without an `input`.
+   */
+  readonly inputRequired: "KUBB_INPUT_REQUIRED";
+  /**
+   * 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";
+  /**
+   * A plugin threw while generating.
+   */
+  readonly pluginFailed: "KUBB_PLUGIN_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 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";
+  /**
+   * A post-generate shell hook (`hooks.done`) exited with a failure.
+   */
+  readonly hookFailed: "KUBB_HOOK_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";
+  /**
+   * 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/createStorage.d.ts
 /**
  * Backend that persists generated files. Kubb ships with `fsStorage` (writes
@@ -513,14 +493,85 @@ type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
  */
 declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
 //#endregion
-//#region src/devtools.d.ts
-type DevtoolsOptions = {
+//#region src/defineLogger.d.ts
+/**
+ * Numeric log-level thresholds used internally to compare verbosity.
+ *
+ * Higher numbers are more verbose.
+ */
+declare const logLevel: {
+  readonly silent: number;
+  readonly error: 0;
+  readonly warn: 1;
+  readonly info: 3;
+  readonly verbose: 4;
+};
+/**
+ * Options accepted by a logger's `install` callback.
+ */
+type LoggerOptions = {
   /**
-   * Open the AST inspector in Kubb Studio (`/ast`). Defaults to the main Studio page.
-   * @default false
+   * Output verbosity. Use the `logLevel` constants exported from `@kubb/core`
+   * (`silent`, `error`, `warn`, `info`, `verbose`, `debug`).
+   */
+  logLevel: (typeof logLevel)[keyof typeof logLevel];
+};
+/**
+ * Event emitter handed to `Logger.install`. Use `.on('kubb:info', ...)` and
+ * friends to subscribe to build events.
+ */
+type LoggerContext = AsyncEventEmitter<KubbHooks>;
+/**
+ * Logger contract. A logger receives the build's event emitter and subscribes
+ * to whichever lifecycle events it wants to forward to its destination
+ * (console, file, remote sink).
+ */
+type Logger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = {
+  /**
+   * Display name used in diagnostics.
    */
-  ast?: boolean;
+  name: string;
+  /**
+   * Called once per build with the shared event emitter. Subscribe to events
+   * here. The return value (if any) is forwarded to whoever installed the
+   * logger, which is handy for sink factories.
+   */
+  install: (context: LoggerContext, options?: TOptions) => TInstallReturn | Promise<TInstallReturn>;
 };
+type UserLogger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = Logger<TOptions, TInstallReturn>;
+/**
+ * Defines a typed logger. Use the second type parameter to declare a return
+ * value from `install`, which is handy when the logger exposes a sink factory
+ * or cleanup callback to the caller.
+ *
+ * @example Basic logger
+ * ```ts
+ * import { defineLogger } from '@kubb/core'
+ *
+ * export const myLogger = defineLogger({
+ *   name: 'my-logger',
+ *   install(context) {
+ *     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
+ *     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
+ *   },
+ * })
+ * ```
+ *
+ * @example Logger that returns a hook sink factory
+ * ```ts
+ * import { defineLogger, type LoggerOptions } from '@kubb/core'
+ * import type { HookSinkFactory } from './sinks'
+ *
+ * export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
+ *   name: 'my-logger',
+ *   install(context) {
+ *     // … register event handlers …
+ *     return () => ({ onStdout: console.log })
+ *   },
+ * })
+ * ```
+ */
+declare function defineLogger<Options extends LoggerOptions = LoggerOptions, TInstallReturn = void>(logger: UserLogger<Options, TInstallReturn>): Logger<Options, TInstallReturn>;
 //#endregion
 //#region src/createReporter.d.ts
 /**
@@ -562,9 +613,9 @@ type ReporterContext = {
   logLevel: (typeof logLevel)[keyof typeof logLevel];
 };
 /**
- * Reporter contract. Unlike a Logger (the live TUI view), a reporter never sees the event
- * emitter. `report` is called once per config with its {@link GenerationResult} and produces
- * output (a terminal summary, a JSON report, a log file).
+ * Host-facing reporter, as installed onto a run. Unlike a Logger (the live TUI view), a reporter
+ * never sees the event emitter. `report` runs once per config; `drain`, when present, runs once
+ * after the last config.
  */
 type Reporter = {
   /**
@@ -575,12 +626,27 @@ type Reporter = {
    * Called once per config with that config's result and the render context.
    */
   report: (result: GenerationResult, context: ReporterContext) => void | Promise<void>;
+  /**
+   * Optional finalizer called once after the run's last config. The host wires it to
+   * `kubb:lifecycle:end`. {@link createReporter} closes it over the reports `report` returned.
+   */
+  drain?: (context: ReporterContext) => void | Promise<void>;
+};
+/**
+ * Reporter definition passed to {@link createReporter}. `report` returns the value to collect for
+ * this config (e.g. a built report), and the optional `drain` receives the collected reports to
+ * emit as one document. `T` is inferred from `report`'s return type.
+ */
+type UserReporter<T = void> = {
+  name: string;
+  report: (result: GenerationResult, context: ReporterContext) => T | Promise<T>;
+  drain?: (context: ReporterContext, reports: Array<T>) => void | Promise<void>;
 };
-type UserReporter = Reporter;
 /**
- * Defines a reporter. Returns the reporter unchanged at runtime. It exists for type inference and
- * to mark the value as a reporter, mirroring {@link defineLogger}. Wiring the reporter onto the
- * run's events is the host's job, so the reporter only ever deals with a {@link GenerationResult}.
+ * Defines a reporter. When the definition has a `drain`, the returned reporter buffers each value
+ * `report` returns and hands the array to `drain` once, then clears it. Without a `drain`, nothing
+ * is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
+ * ever deals with a {@link GenerationResult}.
  *
  * @example
  * ```ts
@@ -589,13 +655,22 @@ type UserReporter = Reporter;
  * export const jsonReporter = createReporter({
  *   name: 'json',
  *   report(result) {
- *     const status = Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success'
- *     process.stdout.write(`${JSON.stringify({ status, diagnostics: result.diagnostics }, null, 2)}\n`)
+ *     return { status: Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success', diagnostics: result.diagnostics }
+ *   },
+ *   drain(context, reports) {
+ *     process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`)
  *   },
  * })
  * ```
  */
-declare function createReporter(reporter: UserReporter): Reporter;
+declare function createReporter<T = void>(reporter: UserReporter<T>): Reporter;
+/**
+ * Picks the reporters whose `name` matches one of `names`, in the order the names are given.
+ * The config carries every available reporter, and the host selects which to activate by name
+ * (the CLI maps `--reporter` to this). Duplicate names and names without a matching reporter are
+ * skipped.
+ */
+declare function selectReporters(reporters: ReadonlyArray<Reporter>, names: ReadonlyArray<string>): Array<Reporter>;
 //#endregion
 //#region src/defineParser.d.ts
 type PrintOptions = {
@@ -687,135 +762,6 @@ type ParsedFile = {
   total: number;
   percentage: number;
 };
-type FileProcessorOptions = {
-  /**
-   * Storage destination for queued writes.
-   */
-  storage: Storage;
-  /**
-   * Parsers indexed by file extension.
-   */
-  parsers?: Map<FileNode['extname'], Parser>;
-  /**
-   * Output extname per source extname, applied during conversion.
-   */
-  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
-};
-/**
- * Turns `FileNode`s into source strings and writes them to storage.
- *
- * Two modes share the same instance. Stateless mode (`parse`, `stream`, `run`) just runs the
- * conversion. Queue mode (`enqueue`, `flush`, `drain`) buffers files deduped by path and
- * writes each batch through storage with up to `STREAM_FLUSH_EVERY` requests in flight.
- *
- * `flush` does not wait for its batch to finish, so dispatch can overlap with IO. The next
- * `flush` or `drain` picks the in-flight batch up. `drain` blocks until everything has been
- * written and is meant for the end of a build.
- *
- * To surface build-level hook signals (`kubb:files:processing:*` and friends) subscribe to
- * `hooks` and re-emit on the kubb bus.
- */
-declare class FileProcessor {
-  #private;
-  readonly hooks: AsyncEventEmitter<FileProcessorHooks>;
-  constructor(options: FileProcessorOptions);
-  /**
-   * Files waiting in the queue.
-   */
-  get size(): number;
-  parse(file: FileNode): string;
-  stream(files: ReadonlyArray<FileNode>): Generator<ParsedFile>;
-  run(files: Array<FileNode>): Promise<Array<FileNode>>;
-  /**
-   * Adds a file to the next flush. A later `enqueue` for the same path replaces the previous
-   * entry, matching `FileManager.upsert`. Fires the `enqueue` event.
-   */
-  enqueue(file: FileNode): void;
-  /**
-   * Starts processing the queued files. Waits for any previous flush to finish (so two
-   * batches never run together) and then returns without waiting for the new one. The next
-   * `flush` or `drain` picks up the in-flight task.
-   */
-  flush(): Promise<void>;
-  /**
-   * Waits for the in-flight flush and writes any files still queued. Fires the `drain` event
-   * when both are done.
-   */
-  drain(): Promise<void>;
-  /**
-   * Clears every listener and the pending queue.
-   */
-  dispose(): void;
-  [Symbol.dispose](): void;
-}
-//#endregion
-//#region src/defineLogger.d.ts
-/**
- * Options accepted by a logger's `install` callback.
- */
-type LoggerOptions = {
-  /**
-   * Output verbosity. Use the `logLevel` constants exported from `@kubb/core`
-   * (`silent`, `error`, `warn`, `info`, `verbose`, `debug`).
-   */
-  logLevel: (typeof logLevel)[keyof typeof logLevel];
-};
-/**
- * Event emitter handed to `Logger.install`. Use `.on('kubb:info', ...)` and
- * friends to subscribe to build events.
- */
-type LoggerContext = AsyncEventEmitter<KubbHooks>;
-/**
- * Logger contract. A logger receives the build's event emitter and subscribes
- * to whichever lifecycle events it wants to forward to its destination
- * (console, file, remote sink).
- */
-type Logger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = {
-  /**
-   * Display name used in diagnostics.
-   */
-  name: string;
-  /**
-   * Called once per build with the shared event emitter. Subscribe to events
-   * here. The return value (if any) is forwarded to whoever installed the
-   * logger, which is handy for sink factories.
-   */
-  install: (context: LoggerContext, options?: TOptions) => TInstallReturn | Promise<TInstallReturn>;
-};
-type UserLogger<TOptions extends LoggerOptions = LoggerOptions, TInstallReturn = void> = Logger<TOptions, TInstallReturn>;
-/**
- * Defines a typed logger. Use the second type parameter to declare a return
- * value from `install`, which is handy when the logger exposes a sink factory
- * or cleanup callback to the caller.
- *
- * @example Basic logger
- * ```ts
- * import { defineLogger } from '@kubb/core'
- *
- * export const myLogger = defineLogger({
- *   name: 'my-logger',
- *   install(context) {
- *     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
- *     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
- *   },
- * })
- * ```
- *
- * @example Logger that returns a hook sink factory
- * ```ts
- * import { defineLogger, type LoggerOptions } from '@kubb/core'
- * import type { HookSinkFactory } from './sinks'
- *
- * export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
- *   name: 'my-logger',
- *   install(context) {
- *     // … register event handlers …
- *     return () => ({ onStdout: console.log })
- *   },
- * })
- * ```
- */
-declare function defineLogger<Options extends LoggerOptions = LoggerOptions, TInstallReturn = void>(logger: UserLogger<Options, TInstallReturn>): Logger<Options, TInstallReturn>;
 //#endregion
 //#region src/defineMiddleware.d.ts
 /**
@@ -1706,7 +1652,7 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * 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
-   * `DiagnosticError` directly.
+   * `Diagnostics.Error` directly.
    */
   warn: (message: string) => void;
   /**
@@ -1719,10 +1665,6 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * the current plugin.
    */
   info: (message: string) => void;
-  /**
-   * Open the current input node in Kubb Studio.
-   */
-  openInStudio: (options?: DevtoolsOptions) => Promise<void>;
   /**
    * The configured adapter instance.
    */
@@ -2086,26 +2028,6 @@ type Config<TInput = Input> = {
    * @see {@link defineMiddleware} to create custom middleware.
    */
   middleware?: Array<Middleware>;
-  /**
-   * Kubb Studio cloud integration settings.
-   *
-   * Kubb Studio (https://kubb.studio) is a web-based IDE for managing API specs and generated code.
-   * Set to `true` to enable with default settings, or pass an object to customize the Studio URL.
-   *
-   * @default false  // disabled by default
-   * @example
-   * ```ts
-   * devtools: true                                   // use default Kubb Studio
-   * devtools: { studioUrl: 'https://my-studio.dev' } // custom Studio instance
-   * ```
-   */
-  devtools?: true | {
-    /**
-     * Override the Kubb Studio base URL.
-     * @default 'https://kubb.studio'
-     */
-    studioUrl?: typeof DEFAULT_STUDIO_URL | (string & {});
-  };
   /**
    * Lifecycle hooks that execute during or after the build process.
    *
@@ -2138,28 +2060,30 @@ type Config<TInput = Input> = {
     done?: string | Array<string>;
   };
   /**
-   * Reporters that render the run's output, like Vitest. List one or more by name;
-   * the CLI `--reporter` flag overrides this when set.
+   * The reporters available to the run, registered as instances. The host
+   * (the CLI via `--reporter`) selects which ones to trigger by `name` with {@link selectReporters}.
+   * `defineConfig` from the `kubb` package registers the built-in `cli`, `json`, and `file`
+   * reporters by default.
    *
    * - `cli` writes the end-of-run summary to the terminal.
    * - `json` writes a machine-readable report to stdout, for CI.
    * - `file` writes a debug log to `.kubb/<name>-<timestamp>.log`.
    *
-   * @default ['cli']
-   *
    * @example
    * ```ts
-   * reporters: ['cli', 'file']
+   * import { cliReporter, jsonReporter } from '@kubb/core'
+   *
+   * reporters: [cliReporter, jsonReporter, myReporter]
    * ```
    */
-  reporters?: Array<ReporterName>;
+  reporters: Array<Reporter>;
 };
 /**
  * Partial `Config` for user-facing entry points with sensible defaults.
  *
  * `UserConfig` is what you pass to `defineConfig()`. It has optional `root`, `plugins`, `parsers`, and `adapter`
  * fields (which fall back to sensible defaults). All other Config options are available, including `output`, `input`,
- * `storage`, `middleware`, `devtools`, and `hooks`.
+ * `storage`, `middleware`, and `hooks`.
  *
  * @example
  * ```ts
@@ -2170,7 +2094,7 @@ type Config<TInput = Input> = {
  * })
  * ```
  */
-type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'parsers' | 'adapter' | 'storage'> & {
+type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'parsers' | 'adapter' | 'storage' | 'reporters'> & {
   /**
    * Project root directory, absolute or relative to the config file location.
    * @default process.cwd()
@@ -2196,6 +2120,12 @@ type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'par
    * @default fsStorage()
    */
   storage?: Storage;
+  /**
+   * Reporters available to the run. `defineConfig` registers the built-in `cli`, `json`, and
+   * `file` reporters when omitted.
+   * @default [cliReporter, jsonReporter, fileReporter]  // applied by `defineConfig` from the `kubb` package
+   */
+  reporters?: Array<Reporter>;
 };
 declare global {
   namespace Kubb {
@@ -2610,15 +2540,6 @@ type BuildOutput = {
    */
   storage: Storage;
 };
-/**
- * Type guard to check if a given config has an `input.path`.
- */
-declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> & {
-  input: InputPath;
-};
-declare function isInputPath(config: Config | undefined): config is Config<InputPath> & {
-  input: InputPath;
-};
 type CreateKubbOptions = {
   hooks?: AsyncEventEmitter<KubbHooks>;
 };
@@ -2820,7 +2741,7 @@ type UpdateDiagnostic = {
  */
 type Diagnostic = ProblemDiagnostic | PerformanceDiagnostic | UpdateDiagnostic;
 /**
- * Maps each {@link DiagnosticCode} to the variant it selects, for {@link narrowDiagnostic}.
+ * 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.
  */
@@ -2830,44 +2751,13 @@ type DiagnosticByCode = Record<ProblemCode, ProblemDiagnostic> & Record<typeof d
  *
  * @example
  * ```ts
- * const update = narrowDiagnostic(diagnostic, diagnosticCode.updateAvailable)
+ * const update = narrow(diagnostic, diagnosticCode.updateAvailable)
  * if (update) {
  *   console.log(update.latestVersion)
  * }
  * ```
  */
-declare function narrowDiagnostic<C extends DiagnosticCode>(diagnostic: Diagnostic, code: C): DiagnosticByCode[C] | null;
-/**
- * Returns `true` when the diagnostic is a build {@link ProblemDiagnostic}.
- *
- * @example
- * ```ts
- * if (isProblemDiagnostic(diagnostic)) {
- *   console.log(diagnostic.location)
- * }
- * ```
- */
-declare const isProblemDiagnostic: (diagnostic: Diagnostic) => diagnostic is ProblemDiagnostic;
-/**
- * Returns `true` when the diagnostic is a per-plugin {@link PerformanceDiagnostic}.
- *
- * @example
- * ```ts
- * const timings = diagnostics.filter(isPerformanceDiagnostic)
- * ```
- */
-declare const isPerformanceDiagnostic: (diagnostic: Diagnostic) => diagnostic is PerformanceDiagnostic;
-/**
- * Returns `true` when the diagnostic is a version-update {@link UpdateDiagnostic}.
- *
- * @example
- * ```ts
- * if (isUpdateDiagnostic(diagnostic)) {
- *   console.log(diagnostic.latestVersion)
- * }
- * ```
- */
-declare const isUpdateDiagnostic: (diagnostic: Diagnostic) => diagnostic is UpdateDiagnostic;
+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
@@ -2885,24 +2775,6 @@ type SerializedDiagnostic = {
    */
   docsUrl?: string;
 };
-/**
- * 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 DiagnosticError({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
- * ```
- */
-declare class DiagnosticError extends Error {
-  diagnostic: ProblemDiagnostic;
-  constructor(diagnostic: ProblemDiagnostic);
-}
-/**
- * Explanation for every {@link diagnosticCode}. Use {@link Diagnostics.explain} to look one up
- * and `Diagnostics.docsUrl` for the matching kubb.dev page.
- */
-declare const diagnosticCatalog: Record<DiagnosticCode, DiagnosticDoc>;
 /**
  * Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
  * that lets deep code report a diagnostic without threading a callback.
@@ -2914,6 +2786,75 @@ declare const diagnosticCatalog: Record<DiagnosticCode, DiagnosticDoc>;
  */
 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 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.
@@ -2933,7 +2874,7 @@ declare class Diagnostics {
    */
   static emit(hooks: AsyncEventEmitter<KubbHooks>, diagnostic: ProblemDiagnostic | UpdateDiagnostic): Promise<void>;
   /**
-   * Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link DiagnosticError}
+   * 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;
@@ -2998,7 +2939,25 @@ declare class Diagnostics {
    * fields are omitted rather than set to `undefined`.
    */
   static serialize(diagnostic: Diagnostic): SerializedDiagnostic;
+  /**
+   * Renders a {@link Diagnostic} for terminal output as its parts: the colored severity `symbol`
+   * (the gutter glyph), the `plugin(CODE): message` `headline`, and the `details` lines (optional
+   * `at <pointer>`, `help:`, and `docs:`).
+   *
+   * Hosts compose these to fit their gutter: a clack logger passes `symbol` as its own gutter and
+   * `[headline, ...details]` as the message, while plain text outputs use {@link Diagnostics.formatLines}.
+   */
+  static format(diagnostic: Diagnostic): {
+    symbol: string;
+    headline: string;
+    details: Array<string>;
+  };
+  /**
+   * The self-contained block form of {@link Diagnostics.format}: `${symbol} ${headline}` followed by
+   * the detail lines. Used where there is no gutter to own the symbol (plain and file output).
+   */
+  static formatLines(diagnostic: Diagnostic): Array<string>;
 }
 //#endregion
-export { Exclude$1 as $, KubbFileProcessingUpdate as A, Parser as At, KubbLifecycleStartContext as B, RendererFactory as Bt, InputPath as C, LoggerContext as Ct, KubbConfigEndContext as D, FileProcessor as Dt, KubbBuildStartContext as E, defineLogger as Et, KubbGenerationStartContext as F, ReporterName as Ft, UserConfig as G, AdapterFactoryOptions as Gt, KubbSuccessContext as H, Storage as Ht, KubbHookEndContext as I, UserReporter as It, Generator$1 as J, diagnosticCode as Jt, createKubb as K, AdapterSource as Kt, KubbHookStartContext as L, createReporter as Lt, KubbFilesProcessingStartContext as M, GenerationResult as Mt, KubbFilesProcessingUpdateContext as N, Reporter as Nt, KubbDiagnosticContext as O, FileProcessorHooks as Ot, KubbGenerationEndContext as P, ReporterContext as Pt, FileManager as Q, KubbHooks as R, DevtoolsOptions as Rt, InputData as S, Logger as St, KubbBuildEndContext as T, UserLogger as Tt, KubbWarnContext as U, createStorage as Ut, KubbPluginsEndContext as V, createRenderer as Vt, PossibleConfig as W, Adapter as Wt, defineGenerator as X, AsyncEventEmitter as Xt, GeneratorContext as Y, logLevel as Yt, KubbDriver as Z, isUpdateDiagnostic as _, ResolverFileParams as _t, DiagnosticKind as a, NormalizedPlugin as at, CLIOptions as b, Middleware as bt, Diagnostics as c, Plugin as ct, ProblemDiagnostic as d, BannerMeta as dt, Group as et, SerializedDiagnostic as f, ResolveBannerContext as ft, isProblemDiagnostic as g, ResolverContext as gt, isPerformanceDiagnostic as h, Resolver as ht, DiagnosticError as i, KubbPluginStartContext as it, KubbFilesProcessingEndContext as j, defineParser as jt, KubbErrorContext as k, ParsedFile as kt, PerformanceDiagnostic as l, PluginFactoryOptions as lt, diagnosticCatalog as m, ResolveOptionsContext as mt, DiagnosticByCode as n, KubbPluginEndContext as nt, DiagnosticLocation as o, Output as ot, UpdateDiagnostic as p, ResolveBannerFile as pt, isInputPath as q, createAdapter as qt, DiagnosticDoc as r, KubbPluginSetupContext as rt, DiagnosticSeverity as s, Override as st, Diagnostic as t, Include as tt, ProblemCode as u, definePlugin as ut, narrowDiagnostic as v, ResolverPathParams as vt, Kubb$1 as w, LoggerOptions as wt, Config as x, defineMiddleware as xt, BuildOutput as y, defineResolver as yt, KubbInfoContext as z, Renderer as zt };
-//# sourceMappingURL=diagnostics-B0ONXReg.d.ts.map
+export { Override as $, KubbHookEndContext as A, logLevel as At, createKubb as B, AsyncEventEmitter as Bt, KubbErrorContext as C, createReporter as Ct, KubbFilesProcessingUpdateContext as D, LoggerOptions as Dt, KubbFilesProcessingStartContext as E, LoggerContext as Et, KubbPluginsEndContext as F, createStorage as Ft, Exclude$1 as G, GeneratorContext as H, KubbSuccessContext as I, Adapter as It, KubbPluginEndContext as J, Group as K, KubbWarnContext as L, AdapterFactoryOptions as Lt, KubbHooks as M, RendererFactory as Mt, KubbInfoContext as N, createRenderer as Nt, KubbGenerationEndContext as O, UserLogger as Ot, KubbLifecycleStartContext as P, Storage as Pt, Output as Q, PossibleConfig as R, AdapterSource as Rt, KubbDiagnosticContext as S, UserReporter as St, KubbFilesProcessingEndContext as T, Logger as Tt, defineGenerator as U, Generator$1 as V, KubbDriver as W, KubbPluginStartContext as X, KubbPluginSetupContext as Y, NormalizedPlugin as Z, InputPath as _, defineParser as _t, DiagnosticLocation as a, ResolveBannerFile as at, KubbBuildStartContext as b, ReporterContext as bt, PerformanceDiagnostic as c, ResolverContext as ct, SerializedDiagnostic as d, defineResolver as dt, Plugin as et, UpdateDiagnostic as f, Middleware as ft, InputData as g, Parser as gt, Config as h, ParsedFile as ht, DiagnosticKind as i, ResolveBannerContext as it, KubbHookStartContext as j, Renderer as jt, KubbGenerationStartContext as k, defineLogger as kt, ProblemCode as l, ResolverFileParams as lt, CLIOptions as m, FileProcessorHooks as mt, DiagnosticByCode as n, definePlugin as nt, DiagnosticSeverity as o, ResolveOptionsContext as ot, BuildOutput as p, defineMiddleware as pt, Include as q, DiagnosticDoc as r, BannerMeta as rt, Diagnostics as s, Resolver as st, Diagnostic as t, PluginFactoryOptions as tt, ProblemDiagnostic as u, ResolverPathParams as ut, Kubb$1 as v, GenerationResult as vt, KubbFileProcessingUpdate as w, selectReporters as wt, KubbConfigEndContext as x, ReporterName as xt, KubbBuildEndContext as y, Reporter as yt, UserConfig as z, createAdapter as zt };
+//# sourceMappingURL=diagnostics-DhfW8YpT.d.ts.map