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

package/dist/{diagnostics-DuaXn2bT.d.ts → Diagnostics-PnPLU3kj.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>;
 /**
@@ -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
@@ -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/createResolver.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,93 @@ 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;
+type ResolverBuildOptions = {
+  pluginName: string;
+  name?: (name: string) => string;
+  file?: (params: ResolverFileParams, context: ResolverContext) => FileNode;
+  [key: string]: unknown;
+};
+/**
+ * Partial resolver fields accepted by `Resolver.merge` and `setResolver`.
+ */
+type ResolverOverride = Omit<ResolverBuildOptions, 'pluginName'>;
+/**
+ * The plugin-specific resolver fields handed to `createResolver`. `name` and `file` fall
+ * back to the built-ins when omitted. Every method reaches sibling helpers through `this`,
+ * which `ThisType` types as the full resolver.
+ */
+type ResolverOptions<T extends PluginFactoryOptions> = Omit<T['resolver'], keyof Resolver> & {
   pluginName: T['name'];
+  name?: T['resolver']['name'];
+  file?: T['resolver']['file'];
 } & ThisType<T['resolver']>;
 /**
- * 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'
- * ```
+ * Base constraint for all plugin resolver objects.
  *
- * @example Tag-based grouping
- * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', tag: 'pets' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
- * )
- * // → '/src/types/pets/petTypes.ts'
- * ```
+ * 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 Path-based grouping
+ * @example Top-level helper
  * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts', path: '/pets/list' },
- *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
- * )
- * // → '/src/types/pets/petTypes.ts'
+ * type MyResolver = Resolver & {
+ *   typeName(name: string): string
+ * }
  * ```
  *
- * @example Single file (`mode: 'file'`)
+ * @example Grouped namespace
  * ```ts
- * defaultResolvePath(
- *   { baseName: 'petTypes.ts' },
- *   { root: '/src', output: { path: 'types.ts', mode: 'file' } },
- * )
- * // → '/src/types.ts'
+ * type MyResolver = Resolver & {
+ *   query: {
+ *     name(node: OperationNode): string
+ *     keyName(node: OperationNode): string
+ *   }
+ * }
  * ```
  */
+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: ResolverOverride | Resolver): 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:
+ * Defines a plugin resolver, the object that decides what every generated symbol and file
+ * path is called. Override the top-level `name` and `file` to set the plugin's conventions,
+ * and add your own naming helpers, top-level (`typeName`, …) or grouped in namespaces
+ * (`query`, `schema`, …). Every method reaches sibling helpers and the built-in machinery
+ * through `this.name`, `this.file`, and `this.default`.
  *
- * - `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.
- *
- * 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')`.
- *
- * @example Basic resolver with naming helpers
+ * @example Custom identifier and file casing
  * ```ts
- * export const resolverTs = defineResolver<PluginTs>(() => ({
- *   name: 'default',
- *   resolveName(name) {
- *     return this.default(name, 'function')
+ * export const resolverTs = createResolver<PluginTs>({
+ *   pluginName: 'plugin-ts',
+ *   name(name) {
+ *     return ensureValidVarName(pascalCase(name))
  *   },
- *   resolveTypeName(name) {
- *     return this.default(name, 'type')
+ *   file(params, context) {
+ *     return this.default.file({ ...params, resolveName: (name) => toFilePath(name, pascalCase) }, context)
  *   },
- * }))
- * ```
- *
- * @example Custom output path
- * ```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)
- *   },
- * }))
+ * })
  * ```
  */
-declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
+declare function createResolver<T extends PluginFactoryOptions>(options: ResolverOptions<T>): T['resolver'];
 //#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 +723,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 +865,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 +883,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 +896,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 +920,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 +938,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 +967,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: ResolverOverride): 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.
@@ -1255,50 +1103,215 @@ 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/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 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>;
   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
@@ -1317,10 +1330,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.
@@ -1361,10 +1373,10 @@ 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`.
+   * for a plugin.
    */
   hasEventGenerators(pluginName: string): boolean;
   /**
@@ -1412,12 +1424,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: ResolverOverride): 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;
@@ -1491,11 +1503,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,65 +1640,6 @@ 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>;
@@ -1755,46 +1708,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] : {};
@@ -2520,19 +2435,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 +2619,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;
@@ -2885,5 +2797,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, ReporterName as At, Kubb$1 as B, KubbFilesProcessingEndContext as C, RendererFactory as Ct, KubbGenerationStartContext as D, GenerationResult as Dt, KubbGenerationEndContext as E, createStorage as Et, KubbSuccessContext as F, AdapterFactoryOptions as Ft, KubbDriver as G, Generator as H, KubbWarnContext as I, AdapterSource as It, Parser as J, FileManagerHooks as K, PossibleConfig as L, createAdapter as Lt, KubbInfoContext as M, createReporter as Mt, KubbLifecycleStartContext as N, logLevel as Nt, KubbHookEndContext as O, Reporter as Ot, KubbPluginsEndContext as P, Adapter as Pt, Group as Q, UserConfig as R, KubbFileProcessingUpdate as S, Renderer as St, KubbFilesProcessingUpdateContext as T, Storage 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, UserReporter as jt, KubbHookLineContext as k, ReporterContext 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, AsyncEventEmitter 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, createRenderer as wt, KubbErrorContext as x, createResolver as xt, KubbBuildStartContext as y, ResolverOverride as yt, CreateKubbOptions as z };
+//# sourceMappingURL=Diagnostics-PnPLU3kj.d.ts.map