@kubb/core 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/{diagnostics-DuaXn2bT.d.ts → Diagnostics-aWJg-H2d.d.ts}

@@ -1,88 +1,6 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Enforce, FileNode, HttpMethod, ImportNode, InputMeta, InputNode, Macro, Node, OperationNode, SchemaNode, UserFileNode } from "@kubb/ast";
 
-//#region ../../internals/utils/src/asyncEventEmitter.d.ts
-/**
- * A function that can be registered as an event listener, synchronous or async.
- */
-type AsyncListener<TArgs extends Array<unknown>> = (...args: TArgs) => void | Promise<void>;
-/**
- * Typed `EventEmitter` that awaits all async listeners before resolving.
- * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
- *
- * @example
- * ```ts
- * const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
- * emitter.on('build', async (name) => { console.log(name) })
- * await emitter.emit('build', 'petstore') // all listeners awaited
- * ```
- */
-declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: Array<unknown> }> {
-  #private;
-  /**
-   * Maximum number of listeners per event before Node emits a memory-leak warning.
-   * @default 10
-   */
-  constructor(maxListener?: number);
-  /**
-   * Emits `eventName` and awaits all registered listeners sequentially.
-   * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-   *
-   * @example
-   * ```ts
-   * await emitter.emit('build', 'petstore')
-   * ```
-   */
-  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void> | void;
-  /**
-   * Registers a persistent listener for `eventName`.
-   *
-   * @example
-   * ```ts
-   * emitter.on('build', async (name) => { console.log(name) })
-   * ```
-   */
-  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
-  /**
-   * Removes a previously registered listener.
-   *
-   * @example
-   * ```ts
-   * emitter.off('build', handler)
-   * ```
-   */
-  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
-  /**
-   * Returns the number of listeners registered for `eventName`.
-   *
-   * @example
-   * ```ts
-   * emitter.on('build', handler)
-   * emitter.listenerCount('build') // 1
-   * ```
-   */
-  listenerCount<TEventName extends keyof TEvents & string>(eventName: TEventName): number;
-  /**
-   * Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
-   * Set this above the expected listener count when many listeners attach by design.
-   *
-   * @example
-   * ```ts
-   * emitter.setMaxListeners(40)
-   * ```
-   */
-  setMaxListeners(max: number): void;
-  /**
-   * Removes all listeners from every event channel.
-   *
-   * @example
-   * ```ts
-   * emitter.removeAll()
-   * ```
-   */
-  removeAll(): void;
-}
-//#endregion
 //#region ../../internals/utils/src/promise.d.ts
 /** A value that may already be resolved or still pending.
  *
@@ -179,14 +97,6 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
   validate: (input: string, options?: {
     throwOnError?: boolean;
   }) => Promise<void>;
-  /**
-   * Memory-efficient streaming variant of `parse()`.
-   *
-   * Returns an `InputNode<true>` whose `schemas` and `operations` are `AsyncIterable`.
-   * Each `for await` loop creates a fresh parse pass over the cached in-memory document.
-   * No pre-built arrays are held in memory.
-   */
-  stream?: (source: AdapterSource) => Promise<InputNode<true>>;
 };
 type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
 /**
@@ -367,7 +277,7 @@ type ReporterContext = {
 };
 /**
  * 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
+ * never sees the hook emitter. `report` runs once per config. `drain`, when present, runs once
  * after the last config.
  */
 type Reporter = {
@@ -383,7 +293,8 @@ type Reporter = {
    * Optional finalizer called once after the run's last config. The host wires it to
    * `kubb:lifecycle:end`. {@link createReporter} closes it over the values that `report` returned.
    */
-  drain?: (context: ReporterContext) => void | Promise<void>;
+  drain: (context: ReporterContext) => void | Promise<void>;
+  [Symbol.dispose](): void;
 };
 /**
  * Reporter definition passed to {@link createReporter}. `report` returns the value to collect for
@@ -398,7 +309,7 @@ type UserReporter<T = void> = {
 /**
  * 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
+ * is buffered. Wiring the reporter onto the run's hooks is the host's job, so the reporter only
  * ever deals with a {@link GenerationResult}.
  *
  * @example
@@ -517,14 +428,8 @@ type Renderer<TElement = unknown> = {
   render(element: TElement): Promise<void>;
   /**
    * Accumulated {@link FileNode} results produced by the last {@link render} call.
-   * Not populated when {@link stream} is implemented.
    */
   readonly files: Array<FileNode>;
-  /**
-   * When present, core calls this instead of {@link render} and {@link files},
-   * forwarding each file to `FileManager` as soon as it is ready.
-   */
-  stream?(element: TElement): Iterable<FileNode>;
   /**
    * Disposer hook so renderers participate in `using` blocks: `using r = rendererFactory()`
    * runs cleanup on every exit path, including thrown errors.
@@ -568,20 +473,7 @@ type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
  */
 declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
 //#endregion
-//#region src/defineResolver.d.ts
-/**
- * Type/string pattern filter for include/exclude/override matching.
- */
-type PatternFilter = {
-  type: string;
-  pattern: string | RegExp;
-};
-/**
- * Pattern filter with partial option overrides applied when the pattern matches.
- */
-type PatternOverride<TOptions> = PatternFilter & {
-  options: Omit<Partial<TOptions>, 'override'>;
-};
+//#region src/Resolver.d.ts
 /**
  * Context for resolving filtered options for a given operation or schema node.
  *
@@ -589,43 +481,33 @@ type PatternOverride<TOptions> = PatternFilter & {
  */
 type ResolveOptionsContext<TOptions> = {
   options: TOptions;
-  exclude?: Array<PatternFilter>;
-  include?: Array<PatternFilter>;
-  override?: Array<PatternOverride<TOptions>>;
+  exclude?: Array<Filter>;
+  include?: Array<Filter>;
+  override?: Array<Override<TOptions>>;
 };
 /**
- * Base constraint for all plugin resolver objects.
- *
- * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
- * are injected automatically by `defineResolver`. Extend this type to add custom resolution methods.
- *
- * @example
- * ```ts
- * type MyResolver = Resolver & {
- *   resolveName(node: SchemaNode): string
- *   resolveTypedName(node: SchemaNode): string
- * }
- * ```
+ * The built-in resolution machinery exposed on every resolver as `resolver.default`.
+ * Plugins delegate to it via `this.default.*` and set their own conventions through
+ * the top-level `name` and `file` entries.
  */
-type Resolver = {
-  name: string;
-  pluginName: string;
-  default(name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  resolveOptions<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null;
-  resolvePath(params: ResolverPathParams, context: ResolverContext): string;
-  resolveFile(params: ResolverFileParams, context: ResolverContext): FileNode;
-  resolveBanner(meta: InputMeta | undefined, context: ResolveBannerContext): string | null;
-  resolveFooter(meta: InputMeta | undefined, context: ResolveBannerContext): string | null;
+type ResolverDefault = {
+  /**
+   * Built-in camelCase casing for a generated identifier.
+   */
+  name(name: string): string;
+  options<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null;
+  path(params: ResolverPathParams, context: ResolverContext): string;
+  file(params: ResolverFileParams, context: ResolverContext): FileNode;
+  banner(meta: InputMeta | undefined, context: ResolveBannerContext): string | null;
+  footer(meta: InputMeta | undefined, context: ResolveBannerContext): string | null;
 };
 /**
- * File-specific parameters for `Resolver.resolvePath`.
- *
- * Pass alongside a `ResolverContext` to identify which file to resolve.
+ * File-specific parameters for `resolver.default.path`.
  * Provide `tag` for tag-based grouping or `path` for path-based grouping.
  *
  * @example
  * ```ts
- * resolver.resolvePath(
+ * resolver.default.path(
  *   { baseName: 'petTypes.ts', tag: 'pets' },
  *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
  * )
@@ -644,38 +526,22 @@ type ResolverPathParams = {
   path?: string;
 };
 /**
- * Shared context passed as the second argument to `Resolver.resolvePath` and `Resolver.resolveFile`.
- *
- * Describes where on disk output is rooted, which output config is active, and the optional
- * grouping strategy that controls subdirectory layout.
- *
- * @example
- * ```ts
- * const context: ResolverContext = {
- *   root: config.root,
- *   output,
- *   group,
- * }
- * ```
+ * Shared context passed as the second argument to `resolver.default.path` and
+ * `resolver.default.file`: where output is rooted, which output config is active,
+ * and the optional grouping strategy.
  */
 type ResolverContext = {
   root: string;
   output: Output;
   group?: Group;
-  /**
-   * Plugin name used to populate `meta.pluginName` on the resolved file.
-   */
-  pluginName?: string;
 };
 /**
- * File-specific parameters for `Resolver.resolveFile`.
- *
- * Pass alongside a `ResolverContext` to fully describe the file to resolve.
+ * File-specific parameters for `resolver.default.file`.
  * `tag` and `path` are used only when a matching `group` is present in the context.
  *
  * @example
  * ```ts
- * resolver.resolveFile(
+ * resolver.default.file(
  *   { name: 'listPets', extname: '.ts', tag: 'pets' },
  *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
  * )
@@ -693,13 +559,18 @@ type ResolverFileParams = {
    * Path value used when `group.type === 'path'`.
    */
   path?: string;
+  /**
+   * Casing applied to `name` to build the file base name. A plugin's `file` override
+   * threads its own caser here to change file naming without reimplementing the builder.
+   *
+   * @default toFilePath
+   */
+  resolveName?: (name: string) => string;
 };
 /**
- * Per-file context describing the file a banner/footer is being resolved for.
- *
- * Supplied by the generator (or the barrel plugin) at resolve-time and merged
- * into `BannerMeta` so a `banner`/`footer` function can branch on the file kind,
- * e.g. omit a `'use server'` directive on re-export files.
+ * Per-file context describing the file a banner/footer is being resolved for, so a
+ * `banner`/`footer` function can branch on the file kind (e.g. skip a `'use server'`
+ * directive on re-export files).
  */
 type ResolveBannerFile = {
   /**
@@ -722,9 +593,6 @@ type ResolveBannerFile = {
 /**
  * Document metadata extended with per-file context, passed to a `banner`/`footer` function.
  *
- * Carries everything in {@link InputMeta} plus the file the banner is rendered into, so a
- * single function can decide per file (e.g. skip a directive on barrel/aggregation files).
- *
  * @example Skip a directive on re-export files
  * `banner: (meta) => (meta.isBarrel || meta.isAggregation) ? '' : "'use server'"`
  */
@@ -747,17 +615,9 @@ type BannerMeta = InputMeta & {
   isAggregation: boolean;
 };
 /**
- * Context passed to `Resolver.resolveBanner` and `Resolver.resolveFooter`.
- *
- * `output` is optional, since not every plugin configures a banner/footer.
- * `config` carries the global Kubb config, used to derive the default Kubb banner.
- * `file` carries per-file context forwarded to a `banner`/`footer` function.
- *
- * @example
- * ```ts
- * resolver.resolveBanner(meta, { output: { banner: '// generated' }, config })
- * // → '// generated'
- * ```
+ * Context passed to `resolver.default.banner` and `resolver.default.footer`.
+ * `output` is optional since not every plugin configures a banner/footer, and `config`
+ * carries the global Kubb config used to derive the default Kubb banner.
  */
 type ResolveBannerContext = {
   output?: Pick<Output, 'banner' | 'footer'>;
@@ -765,111 +625,67 @@ type ResolveBannerContext = {
   file?: ResolveBannerFile;
 };
 /**
- * Builder type for the plugin-specific resolver fields.
- *
- * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
- * are optional, with built-in fallbacks injected when omitted.
- *
- * Methods in the returned object can call sibling resolver methods via `this`.
+ * Raw resolver fields passed to `createResolver` or patched through `Resolver.merge`.
+ * `default` is the built-in machinery and is not user-settable.
  */
-type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'> & Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
-  name: string;
-  pluginName: T['name'];
-} & ThisType<T['resolver']>;
+type ResolverBuildOptions = {
+  pluginName: string;
+  name?: (name: string) => string;
+  file?: (params: ResolverFileParams, context: ResolverContext) => FileNode;
+  [key: string]: unknown;
+};
 /**
- * Default path resolver used by `defineResolver`.
- *
- * - `mode: 'file'` resolves directly to `output.path` (the full file path, extension included).
- * - `mode: 'directory'` (default) resolves to `output.path/{baseName}`, or into a
- *   subdirectory when `group` and a `tag`/`path` value are provided.
- *
- * A custom `group.name` function overrides the default subdirectory naming.
- * For `tag` groups the default is the camelCased tag.
- * For `path` groups the default is the first path segment after `/`.
- *
- * @example Flat output
- * ```ts
- * defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
- * // → '/src/types/petTypes.ts'
- * ```
- *
- * @example Tag-based grouping
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', tag: 'pets' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
- * )
- * // → '/src/types/pets/petTypes.ts'
- * ```
- *
- * @example Path-based grouping
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', path: '/pets/list' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
- * )
- * // → '/src/types/pets/petTypes.ts'
- * ```
- *
- * @example Single file (`mode: 'file'`)
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts' },
- *   { root: '/src', output: { path: 'types.ts', mode: 'file' } },
- * )
- * // → '/src/types.ts'
- * ```
+ * Partial resolver fields accepted by `Resolver.merge` and `setResolver`. Parameterize with a
+ * concrete resolver type (e.g. `ResolverPatch<ResolverTs>`) to type-check namespace overrides
+ * and bind `this` to the full resolver. The bare form accepts any resolver's fields.
  */
+type ResolverPatch<T extends Resolver = Resolver> = Partial<Omit<T, keyof Resolver>> & {
+  name?: T['name'];
+  file?: T['file'];
+} & ThisType<T>;
 /**
- * Defines a plugin resolver. The resolver is the object that decides what
- * every generated symbol and file path is called. Built-in defaults handle
- * name casing, include/exclude/override filtering, output path computation,
- * and file construction. Supply your own to override any of them:
- *
- * - `default` sets the name casing strategy (camelCase or PascalCase).
- * - `resolveOptions` does include/exclude/override filtering.
- * - `resolvePath` computes the output path.
- * - `resolveFile` builds the full `FileNode`.
- * - `resolveBanner` and `resolveFooter` produce the top and bottom of file text.
+ * Base constraint for all plugin resolver objects.
  *
- * Methods in the returned object can call sibling resolver methods via `this`.
- * A custom rule can delegate to a default, for example `this.default(name, 'type')`.
+ * The built-in machinery lives under `default`. Generators call the top-level `name` and
+ * `file`, and a plugin overrides them to set its conventions. Extend with top-level helpers
+ * (`typeName`, …) and/or grouped namespaces (`query`, `schema`, …).
  *
- * @example Basic resolver with naming helpers
+ * @example Top-level helper
  * ```ts
- * export const resolverTs = defineResolver<PluginTs>(() => ({
- *   name: 'default',
- *   resolveName(name) {
- *     return this.default(name, 'function')
- *   },
- *   resolveTypeName(name) {
- *     return this.default(name, 'type')
- *   },
- * }))
+ * type MyResolver = Resolver & {
+ *   typeName(name: string): string
+ * }
  * ```
  *
- * @example Custom output path
+ * @example Grouped namespace
  * ```ts
- * import path from 'node:path'
- *
- * export const resolverTs = defineResolver<PluginTs>(() => ({
- *   name: 'custom',
- *   resolvePath({ baseName }, { root, output }) {
- *     return path.resolve(root, output.path, 'generated', baseName)
- *   },
- * }))
+ * type MyResolver = Resolver & {
+ *   query: {
+ *     name(node: OperationNode): string
+ *     keyName(node: OperationNode): string
+ *   }
+ * }
  * ```
  */
-declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
+declare class Resolver {
+  #private;
+  readonly pluginName: string;
+  constructor(options: ResolverBuildOptions);
+  /**
+   * The built-in resolution machinery. Always reaches the untouched defaults, even when a
+   * plugin overrides the top-level `name` or `file`.
+   */
+  get default(): ResolverDefault;
+  name(name: string): string;
+  file(params: ResolverFileParams, context: ResolverContext): FileNode;
+  /**
+   * Merges `override` over `base` and returns a new resolver with helpers re-bound.
+   * Each key is replaced wholesale. Used when applying `setResolver` partial overrides.
+   */
+  static merge<T extends Resolver>(base: T, override: ResolverPatch<T> | Resolver): T;
+}
 //#endregion
 //#region src/definePlugin.d.ts
-/**
- * Reads a type from a registry, falling back to `{}` when the key is absent. Lets
- * `Kubb.ConfigOptionsRegistry` and `Kubb.PluginOptionsRegistry` be augmented without
- * touching core.
- *
- * @internal
- */
 type ExtractRegistryKey$1<T, K extends PropertyKey> = K extends keyof T ? T[K] : {};
 /**
  * How a plugin consolidates its generated code into files.
@@ -881,7 +697,7 @@ type OutputMode = 'directory' | 'file';
  * Output configuration shared by every plugin. Each plugin extends this with
  * its own keys via the `Kubb.PluginOptionsRegistry.output` interface merge.
  */
-type Output<_TOptions = unknown> = {
+type Output = {
   /**
    * Directory where the plugin writes its generated code, resolved against the global
    * `output.path` set on `defineConfig`. With `mode: 'file'`, this is the full output file
@@ -1023,6 +839,11 @@ type ByContentType = {
    */
   pattern: string | RegExp;
 };
+/**
+ * Pattern filter for include, exclude, and override rules. Matches operations or schemas
+ * by tag, operationId, path, method, content type, or schema name.
+ */
+type Filter = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
 /**
  * Filter that skips matching operations or schemas during generation, for example
  * deprecated endpoints or internal-only schemas.
@@ -1036,7 +857,7 @@ type ByContentType = {
  * ]
  * ```
  */
-type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Exclude$1 = Filter;
 /**
  * Filter that restricts generation to operations or schemas matching at least
  * one entry. Useful for partial builds (one tag, one API version).
@@ -1049,7 +870,7 @@ type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | ByS
  * ]
  * ```
  */
-type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Include = Filter;
 /**
  * Filter paired with a partial options object. When the filter matches, the
  * options are merged on top of the plugin defaults for that operation only.
@@ -1073,7 +894,7 @@ type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySch
  * ]
  * ```
  */
-type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+type Override<TOptions> = Filter & {
   options: Omit<Partial<TOptions>, 'override'>;
 };
 type PluginFactoryOptions<
@@ -1091,7 +912,7 @@ TOptions extends object = object,
 TResolvedOptions extends object = TOptions,
 /**
  * Resolver that encapsulates naming and path-resolution helpers.
- * Define with `defineResolver` and export alongside the plugin.
+ * Define with `createResolver` and export alongside the plugin.
  */
 TResolver extends Resolver = Resolver> = {
   name: TName;
@@ -1120,9 +941,10 @@ type KubbPluginSetupContext<TFactory extends PluginFactoryOptions = PluginFactor
   addGenerator<TElement = unknown>(...generators: Array<Generator<TFactory, TElement>>): void;
   /**
    * Set or override the resolver for this plugin.
-   * The resolver controls file naming and path resolution.
+   * The resolver controls file naming and path resolution. Overrides merge over the built-in
+   * defaults, so a partial `core` or a single namespace method replaces only what it names.
    */
-  setResolver(resolver: Partial<TFactory['resolver']>): void;
+  setResolver(resolver: ResolverPatch<TFactory['resolver']> | TFactory['resolver']): void;
   /**
    * Add a macro that rewrites AST nodes before they reach generators. Macros run in the order they
    * are added, after any macros from earlier `addMacro` calls.
@@ -1186,8 +1008,8 @@ type Plugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
    */
   options?: TFactory['options'];
   /**
-   * Lifecycle event handlers for this plugin.
-   * Any event from the global `KubbHooks` map can be subscribed to here.
+   * Lifecycle hook handlers for this plugin.
+   * Any hook from the global `KubbHooks` map can be subscribed to here.
    */
   hooks: { [K in keyof KubbHooks as K extends 'kubb:plugin:setup' ? never : K]?: (...args: KubbHooks[K]) => void | Promise<void> } & {
     'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>;
@@ -1209,6 +1031,11 @@ type NormalizedPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptio
   resolver: TOptions['resolver'];
   macros?: Array<Macro>;
   generators?: Array<Generator>;
+  /**
+   * Set by the driver when the plugin registers a generator via `addGenerator()` in
+   * `kubb:plugin:setup`. Drives whether the build walks the AST for this plugin.
+   */
+  hasHookGenerators?: boolean;
   apply?: (config: Config) => boolean;
   version?: string;
 };
@@ -1255,55 +1082,233 @@ type KubbPluginEndContext = {
  */
 declare function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(factory: (options: TFactory['options']) => Plugin<TFactory>): (options?: TFactory['options']) => Plugin<TFactory>;
 //#endregion
-//#region src/FileManager.d.ts
+//#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
+ * for new file types (JSON, Markdown, ...).
+ */
+type Parser<TMeta extends object = object, TNode = unknown> = {
+  /**
+   * Display name used in diagnostics and the parser registry.
+   */
+  name: string;
+  /**
+   * File extensions this parser handles. The driver registers the parser for each
+   * extension in this list. A parser with `undefined` here is not registered, so
+   * files of an unclaimed extension fall back to joining their sources verbatim.
+   *
+   * @example
+   * `['.ts', '.js']`
+   */
+  extNames: Array<FileNode['extname']> | undefined;
+  /**
+   * Serialize the file's AST into source code.
+   */
+  parse(file: FileNode<TMeta>, options?: PrintOptions): 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
+   * back to the parser as `FileNode.sources`.
+   */
+  print(...nodes: Array<TNode>): string;
+};
 /**
- * Hooks fired by a `FileManager`.
+ * 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.
+ *
+ * @example
+ * ```ts
+ * import { defineParser } from '@kubb/core'
+ * import { extractStringsFromNodes } from '@kubb/ast'
  *
- * - `upsert` fires once per resolved file added through `add` or `upsert`.
+ * export const jsonParser = defineParser({
+ *   name: 'json',
+ *   extNames: ['.json'],
+ *   parse(file) {
+ *     return file.sources
+ *       .map((source) => extractStringsFromNodes(source.nodes ?? []))
+ *       .join('\n')
+ *   },
+ *   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;
+}
+//#endregion
+//#region src/FileManager.d.ts
+/**
+ * Hooks fired around a `FileManager#write` batch: `start` before it, `update` per file, `end` after.
  */
 type FileManagerHooks = {
-  upsert: [file: FileNode];
+  start: [files: Array<FileNode>];
+  update: [params: {
+    file: FileNode;
+    source?: string;
+    processed: number;
+    total: number;
+    percentage: number;
+  }];
+  end: [files: Array<FileNode>];
+};
+type ParseOptions = {
+  parsers?: Map<FileNode['extname'], Parser>;
+  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
+};
+type WriteOptions = ParseOptions & {
+  storage: Storage;
 };
 /**
- * In-memory file store for generated files. Files sharing a `path` are merged
- * (sources/imports/exports concatenated). The `files` getter is sorted by
- * path length (barrel `index.ts` last within a bucket).
+ * In-memory file store for generated files, and the writer that turns them into source
+ * strings on `storage`. Files sharing a `path` are merged (sources/imports/exports
+ * concatenated). The `files` getter is sorted by path length (barrel `index.ts` last
+ * within a bucket).
  *
  * @example
  * ```ts
  * const manager = new FileManager()
  * manager.upsert(myFile)
  * manager.files // sorted view
+ * await manager.write(manager.files, { storage: fsStorage() })
  * ```
  */
 declare class FileManager {
   #private;
-  /**
-   * Subscribe to file-store changes. Listeners on `upsert` see each resolved file as it lands
-   * through `add` or `upsert`.
-   */
-  readonly hooks: AsyncEventEmitter<FileManagerHooks>;
+  readonly hooks: Hookable<FileManagerHooks>;
   add(...files: Array<FileNode>): Array<FileNode>;
   upsert(...files: Array<FileNode>): Array<FileNode>;
-  getByPath(path: string): FileNode | null;
-  deleteByPath(path: string): void;
   clear(): void;
   /**
    * Releases all stored files and clears every `hooks` listener. Called by the core after
    * `kubb:build:end`.
    */
   dispose(): void;
-  [Symbol.dispose](): void;
   /**
    * All stored files in stable sort order (shortest path first, barrel files
    * last within a length bucket). Returns a cached view, do not mutate.
    */
   get files(): Array<FileNode>;
+  /**
+   * Converts a file's AST sources (or its `copy` source) into the final on-disk string.
+   */
+  parse(file: FileNode, {
+    parsers,
+    extension
+  }?: ParseOptions): Promise<string>;
+  /**
+   * Converts and writes every file at once, letting `storage.setItem` decide how much of
+   * that runs concurrently.
+   */
+  write(files: Array<FileNode>, {
+    storage,
+    parsers,
+    extension
+  }: WriteOptions): Promise<void>;
 }
 //#endregion
 //#region src/KubbDriver.d.ts
 type Options = {
-  hooks: AsyncEventEmitter<KubbHooks>;
+  hooks: Hookable<KubbHooks>;
 };
 type RequirePluginContext = {
   /**
@@ -1317,10 +1322,9 @@ declare class KubbDriver {
   readonly config: Config;
   readonly options: Options;
   /**
-   * The streaming `InputNode<true>` produced by the adapter. Set after adapter setup.
-   * Parse-only adapters are wrapped automatically.
+   * The `InputNode` produced by the adapter. Set after adapter setup.
    */
-  inputNode: InputNode<true> | null;
+  inputNode: InputNode | null;
   adapter: Adapter | null;
   /**
    * Central file store for all generated files.
@@ -1337,16 +1341,16 @@ declare class KubbDriver {
    * so `run` can parse it later.
    */
   setup(): Promise<void>;
-  get hooks(): AsyncEventEmitter<KubbHooks>;
+  get hooks(): Hookable<KubbHooks>;
   /**
-   * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-   * can configure generators, resolvers, macros and renderers before `buildStart` runs.
-   *
-   * Called once from `run` before the plugin execution loop begins.
+   * Runs each plugin's `kubb:plugin:setup` handler, in plugin order, with a context scoped to that
+   * plugin so `addGenerator`, `setResolver`, `addMacro`, `setMacros`, and `setOptions` target its
+   * `NormalizedPlugin` entry. Called once from `run` before the plugin execution loop begins, so
+   * plugins can configure generators, resolvers, macros, and options before `buildStart`.
    */
-  emitSetupHooks(): Promise<void>;
+  setupHooks(): Promise<void>;
   /**
-   * Registers a generator for the given plugin on the shared event emitter.
+   * Registers a generator for the given plugin on the shared hook emitter.
    *
    * The generator's `schema`, `operation`, and `operations` methods are registered as
    * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
@@ -1361,12 +1365,12 @@ declare class KubbDriver {
   registerGenerator(pluginName: string, generator: Generator): void;
   /**
    * Returns `true` when at least one generator was registered for the given plugin
-   * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+   * via `addGenerator()` in `kubb:plugin:setup`.
    *
-   * Used by the build loop to decide whether to walk the AST and emit generator events
-   * for a plugin that has no static `plugin.generators`.
+   * Used by the build loop to decide whether to walk the AST and emit generator hooks
+   * for a plugin.
    */
-  hasEventGenerators(pluginName: string): boolean;
+  hasHookGenerators(pluginName: string): boolean;
   /**
    * Runs the full plugin pipeline. Returns the diagnostics collected so far even
    * when an outer hook throws, since the orchestrator preserves partial state by capturing
@@ -1412,12 +1416,12 @@ declare class KubbDriver {
    * Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
    * get the up-to-date resolver without going through `getResolver()`.
    */
-  setPluginResolver(pluginName: string, partial: Partial<Resolver>): void;
+  setPluginResolver(pluginName: string, partial: ResolverPatch | Resolver): void;
   /**
    * Returns the resolver for the given plugin.
    *
-   * Resolution order: dynamic resolver set via `setPluginResolver` → static resolver on the
-   * plugin → lazily created default resolver (identity name, no path transforms).
+   * Resolution order: resolver set via `setPluginResolver` → lazily created default
+   * resolver (identity name, no path transforms).
    */
   getResolver<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Kubb.PluginRegistry[TName]['resolver'];
   getResolver<TResolver extends Resolver = Resolver>(pluginName: string): TResolver;
@@ -1478,10 +1482,10 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    */
   upsertFile: (...file: Array<FileNode>) => Promise<void>;
   /**
-   * The build's event bus. Emit or listen to any `KubbHooks` event, for example to react to
+   * The build's hook bus. Emit or listen to any `KubbHooks` hook, for example to react to
    * `kubb:build:end` from inside a generator.
    */
-  hooks: AsyncEventEmitter<KubbHooks>;
+  hooks: Hookable<KubbHooks>;
   /**
    * The current plugin instance.
    */
@@ -1491,11 +1495,11 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * called. Kubb picks a `setResolver` registration first, then the plugin's static
    * `resolver`, then the built-in default.
    *
-   * @example Resolve a type name
-   * `ctx.resolver.default('pet', 'type') // 'Pet'`
+   * @example Resolve a name
+   * `ctx.resolver.name('pet') // 'pet'`
    *
    * @example Resolve an output file
-   * `ctx.resolver.resolveFile({ name: 'pet', extname: '.ts' }, { root, output })`
+   * `ctx.resolver.file({ name: 'pet', extname: '.ts' }, { root, output })`
    */
   resolver: TOptions['resolver'];
   /**
@@ -1628,68 +1632,9 @@ type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TEl
  */
 declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown>(generator: Generator<TOptions, TElement>): Generator<TOptions, TElement>;
 //#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
- * for new file types (JSON, Markdown, ...).
- */
-type Parser<TMeta extends object = object, TNode = unknown> = {
-  /**
-   * Display name used in diagnostics and the parser registry.
-   */
-  name: string;
-  /**
-   * File extensions this parser handles. The driver registers the parser for each
-   * extension in this list. A parser with `undefined` here is not registered, so
-   * files of an unclaimed extension fall back to joining their sources verbatim.
-   *
-   * @example
-   * `['.ts', '.js']`
-   */
-  extNames: Array<FileNode['extname']> | undefined;
-  /**
-   * Serialize the file's AST into source code.
-   */
-  parse(file: FileNode<TMeta>, options?: PrintOptions): 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
-   * back to the parser as `FileNode.sources`.
-   */
-  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.
- *
- * @example
- * ```ts
- * import { defineParser } from '@kubb/core'
- * import { extractStringsFromNodes } from '@kubb/ast'
- *
- * export const jsonParser = defineParser({
- *   name: 'json',
- *   extNames: ['.json'],
- *   parse(file) {
- *     return file.sources
- *       .map((source) => extractStringsFromNodes(source.nodes ?? []))
- *       .join('\n')
- *   },
- *   print(...nodes) {
- *     return nodes.map(String).join('\n')
- *   },
- * })
- * ```
- */
-declare function defineParser<T extends Parser>(parser: T): T;
-//#endregion
 //#region src/createKubb.d.ts
 type CreateKubbOptions = {
-  hooks?: AsyncEventEmitter<KubbHooks>;
+  hooks?: Hookable<KubbHooks>;
 };
 /**
  * Kubb code-generation instance bound to a single config entry. Resolves the user
@@ -1699,18 +1644,18 @@ type CreateKubbOptions = {
  * `createKubb` takes a plain config object (the shape `defineConfig` produces),
  * not a fluent builder.
  *
- * Attach event listeners to `.hooks` before calling `setup()` or `build()`.
+ * Attach hook listeners to `.hooks` before calling `setup()` or `build()`.
  *
  * @example
  * ```ts
  * const kubb = createKubb(userConfig)
- * kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
+ * kubb.hooks.hook('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
  * const { files, diagnostics } = await kubb.safeBuild()
  * ```
  */
 declare class Kubb$1 {
   #private;
-  readonly hooks: AsyncEventEmitter<KubbHooks>;
+  readonly hooks: Hookable<KubbHooks>;
   readonly config: Config;
   constructor(userConfig: UserConfig, options?: CreateKubbOptions);
   get storage(): Storage;
@@ -1755,46 +1700,8 @@ declare class Kubb$1 {
  */
 declare function createKubb(userConfig: UserConfig, options?: CreateKubbOptions): Kubb$1;
 //#endregion
-//#region src/FileProcessor.d.ts
-/**
- * Hooks fired by a `FileProcessor`.
- *
- * - `start` opens a batch, from `run` or a queue flush.
- * - `update` fires once per file as it is converted.
- * - `end` closes a batch.
- * - `enqueue` fires for every `enqueue` call.
- * - `drain` fires when `drain()` empties the queue with no in-flight batch left.
- */
-type FileProcessorHooks = {
-  start: [files: Array<FileNode>];
-  update: [params: {
-    file: FileNode;
-    source?: string;
-    processed: number;
-    total: number;
-    percentage: number;
-  }];
-  end: [files: Array<FileNode>];
-  enqueue: [file: FileNode];
-  drain: [];
-};
-/**
- * Per-file progress record yielded by `stream` and surfaced through the `update` event.
- */
-type ParsedFile = {
-  file: FileNode;
-  source: string;
-  processed: number;
-  total: number;
-  percentage: number;
-};
-//#endregion
 //#region src/types.d.ts
 /**
- * Extracts a type from a registry, falling back to `{}` when the key doesn't exist.
- * Lets plugins augment `Kubb.ConfigOptionsRegistry` and `Kubb.PluginOptionsRegistry`
- * without changing core.
- *
  * @internal
  */
 type ExtractRegistryKey<T, K extends PropertyKey> = K extends keyof T ? T[K] : {};
@@ -2007,7 +1914,7 @@ type Config<TInput = Input> = {
    */
   plugins: Array<Plugin>;
   /**
-   * Lifecycle hooks that run external tools (prettier, eslint, a custom script) on build events.
+   * Lifecycle hooks that run external tools (prettier, eslint, a custom script) at points in the build.
    *
    * Currently supports the `done` hook, which fires after all plugins complete.
    *
@@ -2166,16 +2073,16 @@ declare global {
   }
 }
 /**
- * Lifecycle events emitted during Kubb code generation.
+ * Lifecycle hooks emitted during Kubb code generation.
  * Attach listeners before calling `setup()` or `build()` to observe and react to build progress.
  *
  * @example
  * ```ts
- * kubb.hooks.on('kubb:lifecycle:start', () => {
+ * kubb.hooks.hook('kubb:lifecycle:start', () => {
  *   console.log('Starting Kubb generation')
  * })
  *
- * kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => {
+ * kubb.hooks.hook('kubb:plugin:end', ({ plugin, duration }) => {
  *   console.log(`${plugin.name} completed in ${duration}ms`)
  * })
  * ```
@@ -2411,7 +2318,7 @@ type KubbFilesProcessingEndContext = {
 };
 type KubbHookStartContext = {
   /**
-   * Optional identifier for correlating start/end events.
+   * Optional identifier for correlating start/end hooks.
    */
   id?: string;
   /**
@@ -2429,7 +2336,7 @@ type KubbHookStartContext = {
  */
 type KubbHookLineContext = {
   /**
-   * Identifier matching the corresponding `kubb:hook:start` event.
+   * Identifier matching the corresponding `kubb:hook:start` hook.
    */
   id: string;
   /**
@@ -2439,7 +2346,7 @@ type KubbHookLineContext = {
 };
 type KubbHookEndContext = {
   /**
-   * Optional identifier matching the corresponding `kubb:hook:start` event.
+   * Optional identifier matching the corresponding `kubb:hook:start` hook.
    */
   id?: string;
   /**
@@ -2520,19 +2427,16 @@ type BuildOutput = {
    */
   driver: KubbDriver;
   /**
-   * Read-only view of every file written during this build.
-   * Reads go straight to `config.storage`, nothing extra is held in memory.
+   * 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')`
-   *
-   * @example List all generated file paths
-   * `const paths = await buildOutput.storage.getKeys()`
    */
   storage: Storage;
 };
 //#endregion
-//#region src/diagnostics.d.ts
+//#region src/Diagnostics.d.ts
 /**
  * How serious a diagnostic is. `error` fails the build, `warning` and `info`
  * are reported but do not.
@@ -2707,8 +2611,8 @@ type SerializedDiagnostic = {
  *
  * 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 lazily consumed stream, a generator) reports through
- * `Diagnostics.report` and lands in the same run.
+ * adapter parse, a generator) reports through `Diagnostics.report` and lands
+ * in the same run.
  */
 declare class Diagnostics {
   #private;
@@ -2795,11 +2699,11 @@ declare class Diagnostics {
    */
   static report(diagnostic: Diagnostic): boolean;
   /**
-   * Emits a diagnostic on the run's `kubb:diagnostic` event so the loggers render it live.
-   * Use it instead of calling `hooks.emit('kubb:diagnostic', ...)` directly. To collect a
+   * 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: AsyncEventEmitter<KubbHooks>, diagnostic: ProblemDiagnostic | UpdateDiagnostic): Promise<void>;
+  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.
@@ -2885,5 +2789,5 @@ declare class Diagnostics {
   static formatLines(diagnostic: Diagnostic): Array<string>;
 }
 //#endregion
-export { KubbPluginEndContext as $, KubbHookStartContext as A, logLevel as At, ParsedFile as B, KubbFilesProcessingEndContext as C, createStorage as Ct, KubbGenerationStartContext as D, ReporterName as Dt, KubbGenerationEndContext as E, ReporterContext as Et, KubbSuccessContext as F, AsyncEventEmitter as Ft, defineParser as G, Kubb$1 as H, KubbWarnContext as I, defineGenerator as J, Generator as K, PossibleConfig as L, KubbInfoContext as M, AdapterFactoryOptions as Mt, KubbLifecycleStartContext as N, AdapterSource as Nt, KubbHookEndContext as O, UserReporter as Ot, KubbPluginsEndContext as P, createAdapter as Pt, Include as Q, UserConfig as R, KubbFileProcessingUpdate as S, Storage as St, KubbFilesProcessingUpdateContext as T, Reporter as Tt, createKubb as U, CreateKubbOptions as V, Parser as W, Exclude$1 as X, KubbDriver as Y, Group as Z, InputPath as _, ResolverPathParams as _t, DiagnosticLocation as a, OutputOptions as at, KubbDiagnosticContext as b, RendererFactory as bt, PerformanceDiagnostic as c, PluginFactoryOptions as ct, SerializedDiagnostic as d, ResolveBannerContext as dt, KubbPluginSetupContext as et, UpdateDiagnostic as f, ResolveBannerFile as ft, InputData as g, ResolverFileParams as gt, Config as h, ResolverContext as ht, DiagnosticKind as i, OutputMode as it, KubbHooks as j, Adapter as jt, KubbHookLineContext as k, createReporter as kt, ProblemCode as l, definePlugin as lt, CLIOptions as m, Resolver as mt, DiagnosticByCode as n, NormalizedPlugin as nt, DiagnosticSeverity as o, Override as ot, BuildOutput as p, ResolveOptionsContext as pt, GeneratorContext as q, DiagnosticDoc as r, Output as rt, Diagnostics as s, Plugin as st, Diagnostic as t, KubbPluginStartContext as tt, ProblemDiagnostic as u, BannerMeta as ut, KubbBuildEndContext as v, defineResolver as vt, KubbFilesProcessingStartContext as w, GenerationResult as wt, KubbErrorContext as x, createRenderer as xt, KubbBuildStartContext as y, Renderer as yt, FileProcessorHooks as z };
-//# sourceMappingURL=diagnostics-DuaXn2bT.d.ts.map
+export { Include as $, KubbHookStartContext as A, UserReporter as At, Kubb$1 as B, KubbFilesProcessingEndContext as C, createRenderer as Ct, KubbGenerationStartContext as D, Reporter as Dt, KubbGenerationEndContext as E, GenerationResult as Et, KubbSuccessContext as F, AdapterSource as Ft, KubbDriver as G, Generator as H, KubbWarnContext as I, createAdapter as It, Parser as J, FileManagerHooks as K, PossibleConfig as L, KubbInfoContext as M, logLevel as Mt, KubbLifecycleStartContext as N, Adapter as Nt, KubbHookEndContext as O, ReporterContext as Ot, KubbPluginsEndContext as P, AdapterFactoryOptions as Pt, Group as Q, UserConfig as R, KubbFileProcessingUpdate as S, RendererFactory as St, KubbFilesProcessingUpdateContext as T, createStorage as Tt, GeneratorContext as U, createKubb as V, defineGenerator as W, Exclude$1 as X, defineParser as Y, Filter as Z, InputPath as _, ResolverDefault as _t, DiagnosticLocation as a, OutputMode as at, KubbDiagnosticContext as b, ResolverPathParams 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, ResolverContext as gt, Config as h, Resolver as ht, DiagnosticKind as i, Output as it, KubbHooks as j, createReporter as jt, KubbHookLineContext as k, ReporterName as kt, ProblemCode as l, PluginFactoryOptions as lt, CLIOptions as m, ResolveOptionsContext 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, ResolverFileParams as vt, KubbFilesProcessingStartContext as w, Storage as wt, KubbErrorContext as x, Renderer as xt, KubbBuildStartContext as y, ResolverPatch as yt, CreateKubbOptions as z };
+//# sourceMappingURL=Diagnostics-aWJg-H2d.d.ts.map