@kubb/core 5.0.0-alpha.34 → 5.0.0-alpha.36

package/dist/{PluginDriver-BBi_41VF.d.ts → PluginDriver-C9iBgYbk.d.ts}

@@ -1,7 +1,5 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { FileNode, ImportNode, InputNode, Node, OperationNode, Printer, Printer as Printer$1, PrinterFactoryOptions, PrinterPartial, SchemaNode, Visitor } from "@kubb/ast/types";
-import { HttpMethod } from "@kubb/oas";
-import { KubbReactNode } from "@kubb/renderer-jsx/types";
+import { FileNode, HttpMethod, ImportNode, InputNode, Node, OperationNode, SchemaNode, Visitor } from "@kubb/ast";
 
 //#region ../../internals/utils/src/asyncEventEmitter.d.ts
 /**
@@ -63,6 +61,16 @@ declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[
    * ```
    */
   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;
   /**
    * Removes all listeners from every event channel.
    *
@@ -86,43 +94,58 @@ declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[
  */
 type PossiblePromise<T> = Promise<T> | T;
 //#endregion
-//#region src/FileManager.d.ts
+//#region src/createRenderer.d.ts
 /**
- * In-memory file store for generated files.
+ * Minimal interface any Kubb renderer must satisfy.
  *
- * Files with the same `path` are merged — sources, imports, and exports are concatenated.
- * The `files` getter returns all stored files sorted by path length (shortest first).
+ * The generic `TElement` is the type of the element the renderer accepts —
+ * e.g. `KubbReactElement` for `@kubb/renderer-jsx`, or a custom type for
+ * your own renderer.  Defaults to `unknown` so that generators which do not
+ * care about the element type continue to work without specifying it.
+ *
+ * This allows core to drive rendering without a hard dependency on
+ * `@kubb/renderer-jsx` or any specific renderer implementation.
+ */
+type Renderer<TElement = unknown> = {
+  render(element: TElement): Promise<void>;
+  unmount(error?: Error | number | null): void;
+  readonly files: Array<FileNode>;
+};
+/**
+ * A factory function that produces a fresh {@link Renderer} per render.
+ *
+ * Generators use this to declare which renderer handles their output.
+ */
+type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
+/**
+ * Creates a renderer factory for use in generator definitions.
+ *
+ * Wrap your renderer factory function with this helper to register it as the
+ * renderer for a generator. Core will call this factory once per render cycle
+ * to obtain a fresh renderer instance.
  *
  * @example
  * ```ts
- * import { FileManager } from '@kubb/core'
+ * // packages/renderer-jsx/src/index.ts
+ * export const jsxRenderer = createRenderer(() => {
+ *   const runtime = new Runtime()
+ *   return {
+ *     async render(element) { await runtime.render(element) },
+ *     get files() { return runtime.nodes },
+ *     unmount(error) { runtime.unmount(error) },
+ *   }
+ * })
  *
- * const manager = new FileManager()
- * manager.upsert(myFile)
- * console.log(manager.files) // all stored files
+ * // packages/plugin-zod/src/generators/zodGenerator.tsx
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ * export const zodGenerator = defineGenerator<PluginZod>({
+ *   name: 'zod',
+ *   renderer: jsxRenderer,
+ *   schema(node, options) { return <File ...>...</File> },
+ * })
  * ```
  */
-declare class FileManager {
-  #private;
-  /**
-   * Adds one or more files. Files with the same path are merged — sources, imports,
-   * and exports from all calls with the same path are concatenated together.
-   */
-  add(...files: Array<FileNode>): Array<FileNode>;
-  /**
-   * Adds or merges one or more files.
-   * If a file with the same path already exists, its sources/imports/exports are merged together.
-   */
-  upsert(...files: Array<FileNode>): Array<FileNode>;
-  getByPath(path: string): FileNode | null;
-  deleteByPath(path: string): void;
-  clear(): void;
-  /**
-   * All stored files, sorted by path length (shorter paths first).
-   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
-   */
-  get files(): Array<FileNode>;
-}
+declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
 //#endregion
 //#region src/constants.d.ts
 /**
@@ -248,80 +271,6 @@ type Storage = {
  */
 declare function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage;
 //#endregion
-//#region src/defineGenerator.d.ts
-/**
- * A generator is a named object with optional `schema`, `operation`, and `operations`
- * methods. Each method is called with `this = PluginContext` of the parent plugin,
- * giving full access to `this.config`, `this.resolver`, `this.adapter`,
- * `this.driver`, etc.
- *
- * Return a React element, an array of `FileNode`, or `void` to handle file
- * writing manually via `this.upsertFile`. Both React and core (non-React) generators
- * use the same method signatures — the return type determines how output is handled.
- *
- * @example
- * ```ts
- * export const typeGenerator = defineGenerator<PluginTs>({
- *   name: 'typescript',
- *   schema(node, options) {
- *     const { adapter, resolver, root } = this
- *     return <File ...><Type node={node} resolver={resolver} /></File>
- *   },
- *   operation(node, options) {
- *     return <File ...><OperationType node={node} /></File>
- *   },
- * })
- * ```
- */
-type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /** Used in diagnostic messages and debug output. */name: string;
-  /**
-   * Called for each schema node in the AST walk.
-   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
-   * `options` contains the per-node resolved options (after exclude/include/override).
-   */
-  schema?: (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
-  /**
-   * Called for each operation node in the AST walk.
-   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
-   */
-  operation?: (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
-  /**
-   * Called once after all operations have been walked.
-   * `this` is the parent plugin's context with `adapter` and `inputNode` guaranteed present.
-   */
-  operations?: (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
-};
-/**
- * Defines a generator. Returns the object as-is with correct `this` typings.
- * No type discrimination (`type: 'react' | 'core'`) needed — `applyHookResult`
- * handles React elements and `File[]` uniformly.
- */
-declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(generator: Generator<TOptions>): Generator<TOptions>;
-/**
- * Merges an array of generators into a single generator.
- *
- * The merged generator's `schema`, `operation`, and `operations` methods run
- * the corresponding method from each input generator in sequence, applying each
- * result via `applyHookResult`. This eliminates the need to write the loop
- * manually in each plugin.
- *
- * @param generators - Array of generators to merge into a single generator.
- *
- * @example
- * ```ts
- * const merged = mergeGenerators(generators)
- *
- * return {
- *   name: pluginName,
- *   schema: merged.schema,
- *   operation: merged.operation,
- *   operations: merged.operations,
- * }
- * ```
- */
-declare function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(generators: Array<Generator<TOptions>>): Generator<TOptions>;
-//#endregion
 //#region src/defineParser.d.ts
 type PrintOptions = {
   extname?: FileNode['extname'];
@@ -332,7 +281,8 @@ type Parser<TMeta extends object = any> = {
    * File extensions this parser handles.
    * Use `undefined` to create a catch-all fallback parser.
    *
-   * @example ['.ts', '.js']
+   * @example Handled extensions
+   * `['.ts', '.js']`
    */
   extNames: Array<FileNode['extname']> | undefined;
   /**
@@ -362,6 +312,54 @@ type Parser<TMeta extends object = any> = {
  */
 declare function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta>;
 //#endregion
+//#region src/createKubb.d.ts
+/**
+ * Full output produced by a successful or failed build.
+ */
+type BuildOutput = {
+  /**
+   * Plugins that threw during installation, paired with the caught error.
+   */
+  failedPlugins: Set<{
+    plugin: Plugin;
+    error: Error;
+  }>;
+  files: Array<FileNode>;
+  driver: PluginDriver;
+  /**
+   * Elapsed time in milliseconds for each plugin, keyed by plugin name.
+   */
+  pluginTimings: Map<string, number>;
+  error?: Error;
+  /**
+   * Raw generated source, keyed by absolute file path.
+   */
+  sources: Map<string, string>;
+};
+type KubbOptions = {
+  config: Config;
+  hooks?: AsyncEventEmitter<KubbHooks>;
+};
+/**
+ * Creates a Kubb instance bound to a single config entry.
+ *
+ * The instance holds shared state (`hooks`, `sources`, `driver`, `config`) across the
+ * `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
+ * calling `setup()` or `build()`.
+ *
+ * @example
+ * ```ts
+ * const kubb = createKubb({ config })
+ *
+ * kubb.hooks.on('kubb:plugin:end', (plugin, { duration }) => {
+ *   console.log(`${plugin.name} completed in ${duration}ms`)
+ * })
+ *
+ * const { files, failedPlugins } = await kubb.safeBuild()
+ * ```
+ */
+declare function createKubb(options: KubbOptions): Kubb$1;
+//#endregion
 //#region src/Kubb.d.ts
 type DebugInfo = {
   date: Date;
@@ -387,6 +385,46 @@ type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   parameters?: Array<unknown>;
   output?: unknown;
 };
+/**
+ * The instance returned by {@link createKubb}.
+ */
+type Kubb$1 = {
+  /**
+   * The shared event emitter. Attach listeners here before calling `setup()` or `build()`.
+   */
+  readonly hooks: AsyncEventEmitter<KubbHooks>;
+  /**
+   * Raw generated source, keyed by absolute file path.
+   * Populated after a successful `build()` or `safeBuild()` call.
+   */
+  readonly sources: Map<string, string>;
+  /**
+   * The plugin driver. Available after `setup()` has been called.
+   */
+  readonly driver: PluginDriver | undefined;
+  /**
+   * The resolved config with applied defaults. Available after `setup()` has been called.
+   */
+  readonly config: Config | undefined;
+  /**
+   * Initializes all Kubb infrastructure: validates input, applies config defaults,
+   * runs the adapter, and creates the PluginDriver.
+   *
+   * Calling `build()` or `safeBuild()` without calling `setup()` first will
+   * automatically invoke `setup()` before proceeding.
+   */
+  setup(): Promise<void>;
+  /**
+   * Runs a full Kubb build and throws on any error or plugin failure.
+   * Automatically calls `setup()` if it has not been called yet.
+   */
+  build(): Promise<BuildOutput>;
+  /**
+   * Runs a full Kubb build and captures errors instead of throwing.
+   * Automatically calls `setup()` if it has not been called yet.
+   */
+  safeBuild(): Promise<BuildOutput>;
+};
 /**
  * Events emitted during the Kubb code generation lifecycle.
  * These events can be listened to for logging, progress tracking, and custom integrations.
@@ -394,49 +432,49 @@ type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
  * @example
  * ```typescript
  * import type { AsyncEventEmitter } from '@internals/utils'
- * import type { KubbEvents } from '@kubb/core'
+ * import type { KubbHooks } from '@kubb/core'
  *
- * const events: AsyncEventEmitter<KubbEvents> = new AsyncEventEmitter()
+ * const hooks: AsyncEventEmitter<KubbHooks> = new AsyncEventEmitter()
  *
- * events.on('lifecycle:start', () => {
+ * hooks.on('kubb:lifecycle:start', () => {
  *   console.log('Starting Kubb generation')
  * })
  *
- * events.on('plugin:end', (plugin, { duration }) => {
+ * hooks.on('kubb:plugin:end', (plugin, { duration }) => {
  *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
  * })
  * ```
  */
-interface KubbEvents {
+interface KubbHooks {
   /**
    * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
    */
-  'lifecycle:start': [version: string];
+  'kubb:lifecycle:start': [version: string];
   /**
    * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
    */
-  'lifecycle:end': [];
+  'kubb:lifecycle:end': [];
   /**
    * Emitted when configuration loading starts.
    */
-  'config:start': [];
+  'kubb:config:start': [];
   /**
    * Emitted when configuration loading is complete.
    */
-  'config:end': [configs: Array<Config>];
+  'kubb:config:end': [configs: Array<Config>];
   /**
    * Emitted when code generation phase starts.
    */
-  'generation:start': [config: Config];
+  'kubb:generation:start': [config: Config];
   /**
    * Emitted when code generation phase completes.
    */
-  'generation:end': [config: Config, files: Array<FileNode>, sources: Map<string, string>];
+  'kubb:generation:end': [config: Config, files: Array<FileNode>, sources: Map<string, string>];
   /**
    * Emitted with a summary of the generation results.
    * Contains summary lines, title, and success status.
    */
-  'generation:summary': [config: Config, {
+  'kubb:generation:summary': [config: Config, {
     failedPlugins: Set<{
       plugin: Plugin;
       error: Error;
@@ -449,32 +487,32 @@ interface KubbEvents {
   /**
    * Emitted when code formatting starts (e.g., running Biome or Prettier).
    */
-  'format:start': [];
+  'kubb:format:start': [];
   /**
    * Emitted when code formatting completes.
    */
-  'format:end': [];
+  'kubb:format:end': [];
   /**
    * Emitted when linting starts.
    */
-  'lint:start': [];
+  'kubb:lint:start': [];
   /**
    * Emitted when linting completes.
    */
-  'lint:end': [];
+  'kubb:lint:end': [];
   /**
    * Emitted when plugin hooks execution starts.
    */
-  'hooks:start': [];
+  'kubb:hooks:start': [];
   /**
    * Emitted when plugin hooks execution completes.
    */
-  'hooks:end': [];
+  'kubb:hooks:end': [];
   /**
    * Emitted when a single hook execution starts (e.g., format or lint).
    * The callback should be invoked when the command completes.
    */
-  'hook:start': [{
+  'kubb:hook:start': [{
     id?: string;
     command: string;
     args?: readonly string[];
@@ -482,7 +520,7 @@ interface KubbEvents {
   /**
    * Emitted when a single hook execution completes.
    */
-  'hook:end': [{
+  'kubb:hook:end': [{
     id?: string;
     command: string;
     args?: readonly string[];
@@ -492,38 +530,38 @@ interface KubbEvents {
   /**
    * Emitted when a new version of Kubb is available.
    */
-  'version:new': [currentVersion: string, latestVersion: string];
+  'kubb:version:new': [currentVersion: string, latestVersion: string];
   /**
    * Informational message event.
    */
-  info: [message: string, info?: string];
+  'kubb:info': [message: string, info?: string];
   /**
    * Error event. Emitted when an error occurs during code generation.
    */
-  error: [error: Error, meta?: Record<string, unknown>];
+  'kubb:error': [error: Error, meta?: Record<string, unknown>];
   /**
    * Success message event.
    */
-  success: [message: string, info?: string];
+  'kubb:success': [message: string, info?: string];
   /**
    * Warning message event.
    */
-  warn: [message: string, info?: string];
+  'kubb:warn': [message: string, info?: string];
   /**
    * Debug event for detailed logging.
    * Contains timestamp, log messages, and optional filename.
    */
-  debug: [info: DebugInfo];
+  'kubb:debug': [info: DebugInfo];
   /**
    * Emitted when file processing starts.
    * Contains the list of files to be processed.
    */
-  'files:processing:start': [files: Array<FileNode>];
+  'kubb:files:processing:start': [files: Array<FileNode>];
   /**
    * Emitted for each file being processed, providing progress updates.
    * Contains processed count, total count, percentage, and file details.
    */
-  'file:processing:update': [{
+  'kubb:file:processing:update': [{
     /**
      * Number of files processed so far.
      */
@@ -554,16 +592,16 @@ interface KubbEvents {
    * Emitted when file processing completes.
    * Contains the list of processed files.
    */
-  'files:processing:end': [files: Array<FileNode>];
+  'kubb:files:processing:end': [files: Array<FileNode>];
   /**
    * Emitted when a plugin starts executing.
    */
-  'plugin:start': [plugin: Plugin];
+  'kubb:plugin:start': [plugin: Plugin];
   /**
    * Emitted when a plugin completes execution.
    * Duration in ms.
    */
-  'plugin:end': [plugin: Plugin, result: {
+  'kubb:plugin:end': [plugin: Plugin, result: {
     duration: number;
     success: boolean;
     error?: Error;
@@ -572,70 +610,161 @@ interface KubbEvents {
    * Emitted when plugin hook progress tracking starts.
    * Contains the hook name and list of plugins to execute.
    */
-  'plugins:hook:progress:start': [progress: HookProgress];
+  'kubb:plugins:hook:progress:start': [progress: HookProgress];
   /**
    * Emitted when plugin hook progress tracking ends.
    * Contains the hook name that completed.
    */
-  'plugins:hook:progress:end': [{
+  'kubb:plugins:hook:progress:end': [{
     hookName: PluginLifecycleHooks;
   }];
   /**
    * Emitted when a plugin hook starts processing.
    * Contains strategy, hook name, plugin, parameters, and output.
    */
-  'plugins:hook:processing:start': [execution: HookExecution];
+  'kubb:plugins:hook:processing:start': [execution: HookExecution];
   /**
    * Emitted when a plugin hook completes processing.
    * Contains duration, strategy, hook name, plugin, parameters, and output.
    */
-  'plugins:hook:processing:end': [result: HookResult];
+  'kubb:plugins:hook:processing:end': [result: HookResult];
+  /**
+   * Fired once — before any plugin's `buildStart` runs — so that hook-style plugins
+   * can register generators, configure resolvers/transformers/renderers, or inject
+   * extra files.  All `kubb:plugin:setup` handlers registered via `definePlugin` receive
+   * a plugin-specific context (with the correct `addGenerator` closure).
+   * External tooling can observe this event via `hooks.on('kubb:plugin:setup', …)`.
+   */
+  'kubb:plugin:setup': [ctx: KubbPluginSetupContext];
+  /**
+   * Fired immediately before the plugin execution loop begins.
+   * The adapter has already parsed the source and `inputNode` is available.
+   */
+  'kubb:build:start': [ctx: KubbBuildStartContext];
+  /**
+   * Fired after all files have been written to disk.
+   */
+  'kubb:build:end': [ctx: KubbBuildEndContext];
+  /**
+   * Emitted for each schema node during the AST walk.
+   * Generator listeners registered via `addGenerator()` in `kubb:plugin:setup` respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the per-node resolved options (after exclude/include/override).
+   */
+  'kubb:generate:schema': [node: SchemaNode, ctx: GeneratorContext];
+  /**
+   * Emitted for each operation node during the AST walk.
+   * Generator listeners registered via `addGenerator()` in `kubb:plugin:setup` respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the per-node resolved options (after exclude/include/override).
+   */
+  'kubb:generate:operation': [node: OperationNode, ctx: GeneratorContext];
+  /**
+   * Emitted once after all operations have been walked, with the full collected array.
+   * Generator listeners with an `operations()` method respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the plugin-level resolved options for the batch call.
+   */
+  'kubb:generate:operations': [nodes: Array<OperationNode>, ctx: GeneratorContext];
+}
+declare global {
+  namespace Kubb {
+    interface PluginContext {}
+    /**
+     * Registry that maps plugin names to their `PluginFactoryOptions`.
+     * Augment this interface in each plugin's `types.ts` to enable automatic
+     * typing for `getPlugin` and `requirePlugin`.
+     *
+     * @example
+     * ```ts
+     * // packages/plugin-ts/src/types.ts
+     * declare global {
+     *   namespace Kubb {
+     *     interface PluginRegistry {
+     *       'plugin-ts': PluginTs
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    interface PluginRegistry {}
+  }
 }
 //#endregion
-//#region src/defineConfig.d.ts
+//#region src/definePlugin.d.ts
 /**
- * CLI options derived from command-line flags.
+ * Base hook handlers for all events except `kubb:plugin:setup`.
+ * These handlers have identical signatures regardless of the plugin's
+ * `PluginFactoryOptions` generic — they are split out so that the
+ * interface below only needs to override the one event that depends on
+ * the plugin type.
  */
-type CLIOptions = {
+type PluginHooksBase = { [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void> };
+/**
+ * Plugin hook handlers.
+ *
+ * `kubb:plugin:setup` is typed with the plugin's own `PluginFactoryOptions` so
+ * `ctx.setResolver`, `ctx.setOptions`, `ctx.options` etc. use the correct types.
+ *
+ * Uses interface + method shorthand for `kubb:plugin:setup`
+ * checking, allowing `PluginHooks<PluginTs>` to be assignable to `PluginHooks`.
+ *
+ * @template TFactory - The plugin's `PluginFactoryOptions` type.
+ */
+interface PluginHooks<TFactory extends PluginFactoryOptions = PluginFactoryOptions> extends PluginHooksBase {
+  'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>;
+}
+/**
+ * A hook-style plugin object produced by `definePlugin`.
+ * Instead of flat lifecycle methods, it groups all handlers under a `hooks:` property
+ * (matching Astro's integration naming convention).
+ *
+ * @template TFactory - The plugin's `PluginFactoryOptions` type.
+ */
+type HookStylePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
-   * Path to `kubb.config.js`.
+   * Unique name for the plugin, following the same naming convention as `createPlugin`.
    */
-  config?: string;
+  name: string;
   /**
-   * Enable watch mode for input files.
+   * Plugins that must be registered before this plugin executes.
+   * An error is thrown at startup when any listed dependency is missing.
    */
-  watch?: boolean;
+  dependencies?: Array<string>;
   /**
-   * Logging verbosity for CLI usage.
-   *
-   * - `silent`: hide non-essential logs
-   * - `info`: show general logs (non-plugin-related)
-   * - `debug`: include detailed plugin lifecycle logs
-   * @default 'silent'
+   * The options passed by the user when calling the plugin factory.
    */
-  logLevel?: 'silent' | 'info' | 'debug';
+  options?: TFactory['options'];
+  /**
+   * Lifecycle event handlers for this plugin.
+   * Any event from the global `KubbHooks` map can be subscribed to here.
+   */
+  hooks: PluginHooks<TFactory>;
 };
 /**
- * All accepted forms of a Kubb configuration.
- */
-type ConfigInput = PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>);
-/**
- * Helper for defining a Kubb configuration.
+ * Creates a plugin factory using the new hook-style (`hooks:`) API.
  *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
+ * The returned factory is called with optional options and produces a `HookStylePlugin`
+ * that coexists with plugins created via the legacy `createPlugin` API in the same
+ * `kubb.config.ts`.
+ *
+ * Lifecycle handlers are registered on the `PluginDriver`'s `AsyncEventEmitter`, enabling
+ * both the plugin's own handlers and external tooling (CLI, devtools) to observe every event.
  *
  * @example
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
+ * ```ts
+ * // With PluginFactoryOptions (recommended for real plugins)
+ * export const pluginTs = definePlugin<PluginTs>((options) => ({
+ *   name: 'plugin-ts',
+ *   hooks: {
+ *     'kubb:plugin:setup'(ctx) {
+ *       ctx.setResolver(resolverTs)  // typed as Partial<ResolverTs>
+ *     },
+ *   },
  * }))
- * @deprecated as of Kubb v5, @kubb/core will not expose `defineConfig` anymore. use the `kubb` package instead
+ * ```
  */
-declare function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config;
-declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config;
+declare function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(factory: (options: TFactory['options']) => HookStylePlugin<TFactory>): (options?: TFactory['options']) => HookStylePlugin<TFactory>;
 //#endregion
 //#region src/utils/FunctionParams.d.ts
 type FunctionParamsASTWithoutType = {
@@ -676,11 +805,11 @@ type FileMetaBase = {
 type AddIndexesProps = {
   type: BarrelType | false | undefined;
   /**
-   * Root based on root and output.path specified in the config
+   * Absolute output root derived from config `root` and `output.path`.
    */
   root: string;
   /**
-   * Output for plugin
+   * Output settings for the plugin.
    */
   output: {
     path: string;
@@ -707,80 +836,6 @@ declare function getBarrelFiles(files: Array<FileNode>, {
 }: AddIndexesProps): Promise<Array<FileNode>>;
 //#endregion
 //#region src/types.d.ts
-declare global {
-  namespace Kubb {
-    interface PluginContext {}
-    /**
-     * Registry that maps plugin names to their `PluginFactoryOptions`.
-     * Augment this interface in each plugin's `types.ts` to enable automatic
-     * typing for `getPlugin` and `requirePlugin`.
-     *
-     * @example
-     * ```ts
-     * // packages/plugin-ts/src/types.ts
-     * declare global {
-     *   namespace Kubb {
-     *     interface PluginRegistry {
-     *       'plugin-ts': PluginTs
-     *     }
-     *   }
-     * }
-     * ```
-     */
-    interface PluginRegistry {}
-  }
-}
-/**
- * Config used in `kubb.config.ts`
- *
- * @example
- * import { defineConfig } from '@kubb/core'
- * export default defineConfig({
- * ...
- * })
- */
-type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'parsers' | 'adapter'> & {
-  /**
-   * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
-   * @default process.cwd()
-   */
-  root?: string;
-  /**
-   * An array of parsers used to convert generated files to strings.
-   * Each parser handles specific file extensions (e.g. `.ts`, `.tsx`).
-   *
-   * A catch-all fallback parser is always appended last for any unhandled extension.
-   *
-   * When omitted, `parserTsx` from `@kubb/parser-ts` is used automatically as the
-   * default (requires `@kubb/parser-ts` to be installed as an optional dependency).
-   * @default [parserTsx] — from `@kubb/parser-ts`
-   * @example
-   * ```ts
-   * import { parserTs, tsxParser } from '@kubb/parser-ts'
-   * export default defineConfig({
-   *   parsers: [parserTs, tsxParser],
-   * })
-   * ```
-   */
-  parsers?: Array<Parser>;
-  /**
-   * Adapter that converts the input file into a `@kubb/ast` `InputNode` — the universal
-   * intermediate representation consumed by all Kubb plugins.
-   *
-   * When omitted, `adapterOas()` from `@kubb/adapter-oas` is used automatically as the
-   * default (requires `@kubb/adapter-oas` to be installed as an optional dependency).
-   *
-   * - Use `@kubb/adapter-oas` for OpenAPI / Swagger (default).
-   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
-   *
-   * @default adapterOas() — from `@kubb/adapter-oas`
-   */
-  adapter?: Adapter;
-  /**
-   * An array of Kubb plugins used for generation. Each plugin may have additional configurable options (defined within the plugin itself). If a plugin relies on another plugin, an error will occur if the required dependency is missing. Refer to “pre” for more details.
-   */
-  plugins?: Array<Omit<UnknownUserPlugin, 'inject'>>;
-};
 type InputPath = {
   /**
    * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
@@ -872,6 +927,12 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
     path: string;
   }) => Array<ImportNode>;
 };
+/**
+ * Controls how `index.ts` barrel files are generated.
+ * - `'all'` — exports every generated symbol from every file.
+ * - `'named'` — exports only explicitly named exports.
+ * - `'propagate'` — propagates re-exports from nested barrel files upward.
+ */
 type BarrelType = 'all' | 'named' | 'propagate';
 type DevtoolsOptions = {
   /**
@@ -930,13 +991,14 @@ type Config<TInput = Input> = {
    */
   adapter: Adapter;
   /**
-   * You can use either `input.path` or `input.data`, depending on your specific needs.
+   * Source file or data to generate code from.
+   * Use `input.path` for a file on disk or `input.data` for an inline string or object.
    */
   input: TInput;
   output: {
     /**
-     * The path where all generated files receives exported.
-     * This can be an absolute path or a path relative to the specified root option.
+     * Output directory for generated files.
+     * Accepts an absolute path or a path relative to `root`.
      */
     path: string;
     /**
@@ -1009,11 +1071,28 @@ type Config<TInput = Input> = {
     override?: boolean;
   };
   /**
-   * An array of Kubb plugins that used in the generation.
-   * Each plugin may include additional configurable options(defined in the plugin itself).
-   * If a plugin depends on another plugin, an error is returned if the required dependency is missing. See pre for more details.
+   * An array of Kubb plugins used for code generation.
+   * Each plugin may declare additional configurable options.
+   * If a plugin depends on another, an error is thrown when the dependency is missing.
+   * Use `dependencies` on the plugin to declare execution order.
    */
   plugins: Array<Plugin>;
+  /**
+   * Project-wide renderer factory. All plugins and generators that do not declare their own
+   * `renderer` ultimately fall back to this value.
+   *
+   * The resolution chain is: `generator.renderer` → `plugin.renderer` → `config.renderer` → `undefined` (raw `FileNode[]` mode).
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * export default defineConfig({
+   *   renderer: jsxRenderer,
+   *   plugins: [pluginTs(), pluginZod()],
+   * })
+   * ```
+   */
+  renderer?: RendererFactory;
   /**
    * Devtools configuration for Kubb Studio integration.
    */
@@ -1083,21 +1162,6 @@ type Resolver = {
   resolveBanner(node: InputNode | null, context: ResolveBannerContext): string | undefined;
   resolveFooter(node: InputNode | null, context: ResolveBannerContext): string | undefined;
 };
-/**
- * The user-facing subset of a `Resolver` — everything except the four methods injected by
- * `defineResolver` (`default`, `resolveOptions`, `resolvePath`, and `resolveFile`).
- *
- * All four injected methods can still be overridden by providing them explicitly in the builder.
- *
- * @example
- * ```ts
- * export const resolver = defineResolver<PluginTs>(() => ({
- *   name: 'default',
- *   resolveName(node) { return this.default(node.name, 'function') },
- * }))
- * ```
- */
-type UserResolver = Omit<Resolver, 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>;
 type PluginFactoryOptions<
 /**
  * Name to be used for the plugin.
@@ -1131,42 +1195,66 @@ TResolver extends Resolver = Resolver> = {
   resolvePathOptions: TResolvePathOptions;
   resolver: TResolver;
 };
+/**
+ * @deprecated
+ */
 type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
-   * Unique name used for the plugin
-   * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
-   * @example @kubb/typescript
+   * Unique name used for the plugin.
+   * The name follows the format `scope:foo-bar` or `foo-bar` — adding a scope avoids conflicts with other plugins.
+   *
+   * @example Plugin name
+   * `'@kubb/typescript'`
    */
   name: TOptions['name'];
   /**
-   * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+   * Resolved options merged with output/include/exclude/override defaults for the current plugin.
    */
   options: TOptions['resolvedOptions'] & {
     output: Output;
     include?: Array<Include>;
-    exclude: Array<Exclude>;
+    exclude: Array<Exclude$1>;
     override: Array<Override<TOptions['resolvedOptions']>>;
   };
   /**
    * The resolver for this plugin.
-   * Composed by `getPreset` from the preset resolver and the user's `resolver` partial override.
+   * Set via `setResolver()` in `kubb:plugin:setup` or passed as a user option.
    */
   resolver?: TOptions['resolver'];
   /**
    * The composed transformer for this plugin.
-   * Composed by `getPreset` from the preset's transformers and the user's `transformer` visitor.
-   * When a visitor method returns `null`/`undefined`, the preset transformer's result is used instead.
+   * Set via `setTransformer()` in `kubb:plugin:setup` or passed as a user option.
    */
   transformer?: Visitor;
   /**
-   * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
-   * Can be used to validate dependent plugins.
+   * Plugin-level renderer factory. All generators that do not declare their own `renderer`
+   * inherit this value. A generator can explicitly opt out by setting `renderer: null`.
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * createPlugin((options) => ({
+   *   name: 'my-plugin',
+   *   renderer: jsxRenderer,
+   *   generators: [
+   *     { name: 'types', schema(node) { return <File>...</File> } },   // inherits jsxRenderer
+   *     { name: 'raw', renderer: null, schema(node) { return [...] } }, // explicit opt-out
+   *   ],
+   * }))
+   * ```
    */
-  pre?: Array<string>;
+  renderer?: RendererFactory;
   /**
-   * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin is executed before these plugins.
+   * Generators declared directly on the plugin. Each generator's `renderer` takes precedence
+   * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
+   * when the plugin declares a renderer.
    */
-  post?: Array<string>;
+  generators?: Array<Generator<any>>;
+  /**
+   * Specifies the plugins that the current plugin depends on. The current plugin is executed after all listed plugins.
+   * An error is returned if any required dependency plugin is missing.
+   */
+  dependencies?: Array<string>;
   /**
    * When `apply` is defined, the plugin is only activated when `apply(config)` returns `true`.
    * Inspired by Vite's `apply` option.
@@ -1193,53 +1281,55 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
    */
   inject?: (this: PluginContext<TOptions>) => TOptions['context'];
 };
+/**
+ * @deprecated
+ */
 type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
-type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<string, object, object, unknown, object>>;
 /**
  * Handler for a single schema node. Used by the `schema` hook on a plugin.
  */
-type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
+type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<unknown | Array<FileNode> | void>;
 /**
  * Handler for a single operation node. Used by the `operation` hook on a plugin.
  */
-type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
+type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<unknown | Array<FileNode> | void>;
 /**
  * Handler for all collected operation nodes. Used by the `operations` hook on a plugin.
  */
-type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<KubbReactNode | Array<FileNode> | void>;
+type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<unknown | Array<FileNode> | void>;
+/**
+ * @deprecated will be replaced with HookStylePlugin
+ */
 type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
-   * Unique name used for the plugin
-   * @example @kubb/typescript
+   * Unique name used for the plugin.
+   *
+   * @example Plugin name
+   * `'@kubb/typescript'`
    */
   name: TOptions['name'];
   /**
-   * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
-   * Can be used to validate dependent plugins.
-   */
-  pre?: Array<string>;
-  /**
-   * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin is executed before these plugins.
+   * Specifies the plugins that the current plugin depends on. The current plugin is executed after all listed plugins.
+   * An error is returned if any required dependency plugin is missing.
    */
-  post?: Array<string>;
+  dependencies?: Array<string>;
   /**
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
   options: TOptions['resolvedOptions'] & {
     output: Output;
     include?: Array<Include>;
-    exclude: Array<Exclude>;
+    exclude: Array<Exclude$1>;
     override: Array<Override<TOptions['resolvedOptions']>>;
   };
   /**
    * The resolver for this plugin.
-   * Composed by `getPreset` from the preset resolver and the user's `resolver` partial override.
+   * Set via `setResolver()` in `kubb:plugin:setup` or passed as a user option.
    */
   resolver: TOptions['resolver'];
   /**
-   * The composed transformer for this plugin. Accessible via `context.transformer`.
-   * Composed by `getPreset` from the preset's transformers and the user's `transformer` visitor.
-   * When a visitor method returns `null`/`undefined`, the preset transformer's result is used instead.
+   * The composed transformer for this plugin.
+   * Set via `setTransformer()` in `kubb:plugin:setup` or passed as a user option.
    */
   transformer?: Visitor;
   /**
@@ -1252,6 +1342,17 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
    * Used in diagnostic messages and version-conflict detection.
    */
   version?: string;
+  /**
+   * Plugin-level renderer factory. All generators that do not declare their own `renderer`
+   * inherit this value. A generator can explicitly opt out by setting `renderer: null`.
+   */
+  renderer?: RendererFactory;
+  /**
+   * Generators declared directly on the plugin. Each generator's `renderer` takes precedence
+   * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
+   * when the plugin declares a renderer.
+   */
+  generators?: Array<Generator<any>>;
   buildStart: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
    * Called once per plugin after all files have been written to disk.
@@ -1285,18 +1386,22 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
    */
   inject: (this: PluginContext<TOptions>) => TOptions['context'];
 };
+/**
+ * @deprecated
+ */
 type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
+/**
+ * @deprecated
+ */
 type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Called once per plugin at the start of its processing phase, before schema/operation/operations hooks run.
    * Use this to set up shared state, fetch remote data, or perform any async initialization.
-   * @type hookParallel
    */
   buildStart?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
    * Called once per plugin after all files have been written to disk.
    * Use this for post-processing, copying assets, or generating summary reports.
-   * @type hookParallel
    */
   buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
@@ -1324,22 +1429,29 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    */
   operations?: OperationsHook<TOptions>;
   /**
-   * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
-   * Options can als be included.
-   * @type hookFirst
-   * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
-   * @deprecated this will be replaced by resolvers
+   * Resolves a path from a baseName and directory.
+   * Options can also be included.
+   *
+   * @example
+   * `('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'`
+   *
+   * @deprecated Use resolvers instead.
    */
   resolvePath?: (this: PluginContext<TOptions>, baseName: FileNode['baseName'], mode?: 'single' | 'split', options?: TOptions['resolvePathOptions']) => string;
   /**
-   * Resolve to a name based on a string.
+   * Resolves a display name from a raw string.
    * Useful when converting to PascalCase or camelCase.
-   * @type hookFirst
-   * @example ('pet') => 'Pet'
-   * @deprecated this will be replaced by resolvers
+   *
+   * @example
+   * `('pet') => 'Pet'`
+   *
+   * @deprecated Use resolvers instead.
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
 };
+/**
+ * @deprecated
+ */
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
 type ResolvePathParams<TOptions = object> = {
@@ -1347,7 +1459,7 @@ type ResolvePathParams<TOptions = object> = {
   baseName: FileNode['baseName'];
   mode?: 'single' | 'split';
   /**
-   * Options to be passed to 'resolvePath' 3th parameter
+   * Options passed as the third argument to `resolvePath`.
    */
   options?: TOptions;
 };
@@ -1356,14 +1468,16 @@ type ResolveNameParams = {
   pluginName?: string;
   /**
    * Specifies the type of entity being named.
-   * - 'file' customizes the name of the created file (uses camelCase).
-   * - 'function' customizes the exported function names (uses camelCase).
-   * - 'type' customizes TypeScript types (uses PascalCase).
-   * - 'const' customizes variable names (uses camelCase).
-   * @default undefined
+   * - `'file'` — customizes the name of the created file (camelCase).
+   * - `'function'` — customizes the exported function names (camelCase).
+   * - `'type'` — customizes TypeScript type names (PascalCase).
+   * - `'const'` — customizes variable names (camelCase).
    */
   type?: 'file' | 'function' | 'type' | 'const';
 };
+/**
+ * @deprecated
+ */
 type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config;
   /**
@@ -1393,19 +1507,16 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   requirePlugin<TName extends keyof Kubb.PluginRegistry>(name: TName): Plugin<Kubb.PluginRegistry[TName]>;
   requirePlugin(name: string): Plugin;
   /**
-   * Only add when the file does not exist yet
+   * Add files only when they do not exist yet.
    */
   addFile: (...file: Array<FileNode>) => Promise<void>;
   /**
-   * merging multiple sources into the same output file
+   * Merge multiple sources into the same output file.
    */
   upsertFile: (...file: Array<FileNode>) => Promise<void>;
+  hooks: AsyncEventEmitter<KubbHooks>;
   /**
-   * @deprecated use this.warn, this.error, this.info instead
-   */
-  events: AsyncEventEmitter<KubbEvents>;
-  /**
-   * Current plugin
+   * The current plugin.
    */
   plugin: Plugin<TOptions>;
   /**
@@ -1419,17 +1530,17 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   transformer: Visitor | undefined;
   /**
    * Emit a warning via the build event system.
-   * Shorthand for `this.events.emit('warn', message)`.
+   * Shorthand for `this.hooks.emit('kubb:warn', message)`.
    */
   warn: (message: string) => void;
   /**
    * Emit an error via the build event system.
-   * Shorthand for `this.events.emit('error', error)`.
+   * Shorthand for `this.hooks.emit('kubb:error', error)`.
    */
   error: (error: string | Error) => void;
   /**
    * Emit an info message via the build event system.
-   * Shorthand for `this.events.emit('info', message)`.
+   * Shorthand for `this.hooks.emit('kubb:info', message)`.
    */
   info: (message: string) => void;
   /**
@@ -1445,7 +1556,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    */
   inputNode: InputNode;
   /**
-   * Return the adapter from `@kubb/ast`
+   * The adapter from `@kubb/ast`.
    */
   adapter: Adapter;
 } | {
@@ -1453,23 +1564,27 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   adapter?: never;
 }) & Kubb.PluginContext;
 /**
- * Narrowed `PluginContext` used as the `this` type inside generator and plugin AST hook methods.
+ * Context object passed as the second argument to generator `schema`, `operation`, and
+ * `operations` methods.
+ *
+ * Generators are only invoked from `runPluginAstHooks`, which already guards against a
+ * missing adapter. This type reflects that guarantee — `ctx.adapter` and `ctx.inputNode`
+ * are always defined, so no runtime checks or casts are needed inside generator bodies.
  *
- * Generators and the `schema`/`operation`/`operations` plugin hooks are only invoked from
- * `runPluginAstHooks`, which already guards against a missing adapter. This type reflects
- * that guarantee — `this.adapter` and `this.inputNode` are always defined, so no runtime
- * checks or casts are needed inside the method bodies.
+ * `ctx.options` carries the per-node resolved options for `schema`/`operation` calls
+ * (after exclude/include/override filtering) and the plugin-level options for `operations`.
  */
 type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Omit<PluginContext<TOptions>, 'adapter' | 'inputNode'> & {
   adapter: Adapter;
   inputNode: InputNode;
+  options: TOptions['resolvedOptions'];
 };
 /**
- * Specify the export location for the files and define the behavior of the output
+ * Configure generated file output location and behavior.
  */
 type Output<_TOptions = unknown> = {
   /**
-   * Path to the output folder or file that will contain the generated code
+   * Path to the output folder or file that will contain generated code.
    */
   path: string;
   /**
@@ -1478,11 +1593,13 @@ type Output<_TOptions = unknown> = {
    */
   barrelType?: BarrelType | false;
   /**
-   * Add a banner text in the beginning of every file
+   * Text or function appended at the start of every generated file.
+   * When a function, receives the current `InputNode` and must return a string.
    */
   banner?: string | ((node?: InputNode) => string);
   /**
-   * Add a footer text in the beginning of every file
+   * Text or function appended at the end of every generated file.
+   * When a function, receives the current `InputNode` and must return a string.
    */
   footer?: string | ((node?: InputNode) => string);
   /**
@@ -1493,14 +1610,14 @@ type Output<_TOptions = unknown> = {
 };
 type UserGroup = {
   /**
-   * Defines the type where to group the files.
-   * - 'tag' groups files by OpenAPI tags.
-   * - 'path' groups files by OpenAPI paths.
-   * @default undefined
+   * Determines how files are grouped into subdirectories.
+   * - `'tag'` groups files by OpenAPI tags.
+   * - `'path'` groups files by OpenAPI paths.
    */
   type: 'tag' | 'path';
   /**
-   * Return the name of a group based on the group name, this is used for the file and name generation.
+   * Returns the subdirectory name for a given group value.
+   * Defaults to `${camelCase(group)}Controller` for tags and the first path segment for paths.
    */
   name?: (context: {
     group: string;
@@ -1508,14 +1625,13 @@ type UserGroup = {
 };
 type Group = {
   /**
-   * Defines the type where to group the files.
-   * - 'tag' groups files by OpenAPI tags.
-   * - 'path' groups files by OpenAPI paths.
-   * @default undefined
+   * Determines how files are grouped into subdirectories.
+   * - `'tag'` groups files by OpenAPI tags.
+   * - `'path'` groups files by OpenAPI paths.
    */
   type: 'tag' | 'path';
   /**
-   * Return the name of a group based on the group name, this is used for the file and name generation.
+   * Returns the subdirectory name for a given group value.
    */
   name: (context: {
     group: string;
@@ -1530,7 +1646,7 @@ type LoggerOptions = {
 /**
  * Shared context passed to all plugins, parsers, and other internals.
  */
-type LoggerContext = AsyncEventEmitter<KubbEvents>;
+type LoggerContext = AsyncEventEmitter<KubbHooks>;
 type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
   name: string;
   install: (context: LoggerContext, options?: TOptions) => void | Promise<void>;
@@ -1543,42 +1659,80 @@ type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOption
  */
 type CompatibilityPreset = 'default' | 'kubbV4';
 /**
- * A preset bundles a name, a resolver, optional AST transformers,
- * and optional generators into a single reusable configuration object.
- *
- * @template TResolver - The concrete resolver type for this preset.
+ * Context passed to a hook-style plugin's `kubb:plugin:setup` handler.
+ * Provides methods to register generators, configure the resolver, transformer,
+ * and renderer, as well as access to the current build configuration.
  */
-type Preset<TResolver extends Resolver = Resolver> = {
+type KubbPluginSetupContext<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
-   * Unique identifier for this preset.
+   * Register a generator on this plugin. Generators are invoked during the AST walk
+   * (schema/operation/operations) exactly like generators declared statically on `createPlugin`.
    */
-  name: string;
+  addGenerator<TElement = unknown>(generator: Generator<TFactory, TElement>): void;
   /**
-   * The resolver used by this preset.
+   * Set or partially override the resolver for this plugin.
+   * The resolver controls file naming and path resolution for generated files.
+   *
+   * When `TFactory` is a concrete `PluginFactoryOptions` (e.g. `PluginClient`),
+   * the resolver parameter is typed to the plugin's own resolver type (e.g. `ResolverClient`).
    */
-  resolver: TResolver;
+  setResolver(resolver: Partial<TFactory['resolver']>): void;
   /**
-   * Optional AST visitors / transformers applied after resolving.
+   * Set the AST transformer (visitor) for this plugin.
+   * The transformer pre-processes nodes before they reach the generators.
    */
-  transformers?: Array<Visitor>;
+  setTransformer(visitor: Visitor): void;
   /**
-   * Optional generators used by this preset. Plugin implementations cast this
-   * to their concrete generator type.
+   * Set the renderer factory for this plugin.
+   * Used to process JSX elements returned by generators.
    */
-  generators?: Array<Generator<any>>;
+  setRenderer(renderer: RendererFactory): void;
+  /**
+   * Set the resolved options for the build loop. These options are merged into the
+   * normalized plugin's `options` object (which includes `output`, `exclude`, `override`).
+   *
+   * Call this in `kubb:plugin:setup` to provide the resolved options that generators
+   * and the build loop need (e.g., `enumType`, `optionalType`, `group`).
+   */
+  setOptions(options: TFactory['resolvedOptions']): void;
+  /**
+   * Inject a raw file into the build output, bypassing the normal generation pipeline.
+   */
+  injectFile(file: Pick<FileNode, 'baseName' | 'path'> & {
+    sources?: FileNode['sources'];
+  }): void;
+  /**
+   * Merge a partial config update into the current build configuration.
+   */
+  updateConfig(config: Partial<Config>): void;
+  /**
+   * The resolved build configuration at the time of setup.
+   */
+  config: Config;
   /**
-   * Optional printer factory used by this preset.
-   * The generator calls this function at render-time to produce a configured printer instance.
+   * The plugin's own options as passed by the user.
    */
-  printer?: (options: any) => Printer;
+  options: TFactory['options'];
 };
 /**
- * A named registry of presets, keyed by preset name.
- *
- * @template TResolver - The concrete resolver type shared by all presets in this registry.
- * @template TName - The union of valid preset name keys.
+ * Context passed to a hook-style plugin's `kubb:build:start` handler.
+ * Fires immediately before the plugin execution loop begins.
  */
-type Presets<TResolver extends Resolver = Resolver> = Record<CompatibilityPreset, Preset<TResolver>>;
+type KubbBuildStartContext = {
+  config: Config;
+  adapter: Adapter;
+  inputNode: InputNode;
+  getPlugin(name: string): Plugin | undefined;
+};
+/**
+ * Context passed to a hook-style plugin's `kubb:build:end` handler.
+ * Fires after all files have been written to disk.
+ */
+type KubbBuildEndContext = {
+  files: Array<FileNode>;
+  config: Config;
+  outputDir: string;
+};
 type ByTag = {
   type: 'tag';
   pattern: string | RegExp;
@@ -1603,8 +1757,20 @@ type ByContentType = {
   type: 'contentType';
   pattern: string | RegExp;
 };
-type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+/**
+ * A pattern filter that prevents matching nodes from being generated.
+ * Match by `tag`, `operationId`, `path`, `method`, `contentType`, or `schemaName`.
+ */
+type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+/**
+ * A pattern filter that restricts generation to only matching nodes.
+ * Match by `tag`, `operationId`, `path`, `method`, `contentType`, or `schemaName`.
+ */
 type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+/**
+ * A pattern filter paired with partial option overrides applied when the pattern matches.
+ * Match by `tag`, `operationId`, `path`, `method`, `schemaName`, or `contentType`.
+ */
 type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
   options: Partial<TOptions>;
 };
@@ -1710,6 +1876,160 @@ type ResolveBannerContext = {
   output?: Pick<Output, 'banner' | 'footer'>;
   config: Config;
 };
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
+  /**
+   * Path to `kubb.config.js`.
+   */
+  config?: string;
+  /**
+   * Enable watch mode for input files.
+   */
+  watch?: boolean;
+  /**
+   * Logging verbosity for CLI usage.
+   * @default 'silent'
+   */
+  logLevel?: 'silent' | 'info' | 'debug';
+};
+/**
+ * All accepted forms of a Kubb configuration.
+ *
+ * Config is always `@kubb/core` {@link Config}.
+ * - `PossibleConfig` accepts `Config`/`Config[]`/promise or a no-arg config factory.
+ * - `PossibleConfig<TCliOptions>` accepts the same config forms or a config factory receiving `TCliOptions`.
+ */
+type PossibleConfig<TCliOptions = undefined> = PossiblePromise<Config | Config[]> | ((...args: [TCliOptions] extends [undefined] ? [] : [TCliOptions]) => PossiblePromise<Config | Config[]>);
+/**
+ * All accepted forms of a Kubb configuration.
+ * @deprecated
+ * Kept for backward compatibility. Prefer `PossibleConfig<CLIOptions>` in new code.
+ */
+type ConfigInput = PossibleConfig<CLIOptions>;
+//#endregion
+//#region src/defineGenerator.d.ts
+/**
+ * A generator is a named object with optional `schema`, `operation`, and `operations`
+ * methods. Each method receives the AST node as the first argument and a typed
+ * `ctx` object as the second, giving access to `ctx.config`, `ctx.resolver`,
+ * `ctx.adapter`, `ctx.options`, `ctx.upsertFile`, etc.
+ *
+ * Generators that return renderer elements (e.g. JSX) must declare a `renderer`
+ * factory so that core knows how to process the output without coupling core
+ * to any specific renderer package.
+ *
+ * Return a renderer element, an array of `FileNode`, or `void` to handle file
+ * writing manually via `ctx.upsertFile`.
+ *
+ * @example
+ * ```ts
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ *
+ * export const typeGenerator = defineGenerator<PluginTs>({
+ *   name: 'typescript',
+ *   renderer: jsxRenderer,
+ *   schema(node, ctx) {
+ *     const { adapter, resolver, root, options } = ctx
+ *     return <File ...><Type node={node} resolver={resolver} /></File>
+ *   },
+ *   operation(node, ctx) {
+ *     const { options } = ctx
+ *     return <File ...><OperationType node={node} /></File>
+ *   },
+ * })
+ * ```
+ */
+type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown> = {
+  /**
+   * Used in diagnostic messages and debug output.
+   */
+  name: string;
+  /**
+   * Optional renderer factory that produces a {@link Renderer} for each render cycle.
+   *
+   * Generators that return renderer elements (e.g. JSX via `@kubb/renderer-jsx`) must set this
+   * to the matching renderer factory (e.g. `jsxRenderer` from `@kubb/renderer-jsx`).
+   *
+   * Generators that only return `Array<FileNode>` or `void` do not need to set this.
+   *
+   * Set `renderer: null` to explicitly opt out of rendering even when the parent plugin
+   * declares a `renderer` (overrides the plugin-level fallback).
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * export const myGenerator = defineGenerator<PluginTs>({
+   *   renderer: jsxRenderer,
+   *   schema(node, ctx) { return <File ...>...</File> },
+   * })
+   * ```
+   */
+  renderer?: RendererFactory<TElement> | null;
+  /**
+   * Called for each schema node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  schema?: (node: SchemaNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+  /**
+   * Called for each operation node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  operation?: (node: OperationNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+  /**
+   * Called once after all operations have been walked.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the plugin-level options for the batch call.
+   */
+  operations?: (nodes: Array<OperationNode>, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+};
+/**
+ * Defines a generator. Returns the object as-is with correct `this` typings.
+ * `applyHookResult` handles renderer elements and `File[]` uniformly using
+ * the generator's declared `renderer` factory.
+ */
+declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown>(generator: Generator<TOptions, TElement>): Generator<TOptions, TElement>;
+//#endregion
+//#region src/FileManager.d.ts
+/**
+ * In-memory file store for generated files.
+ *
+ * Files with the same `path` are merged — sources, imports, and exports are concatenated.
+ * The `files` getter returns all stored files sorted by path length (shortest first).
+ *
+ * @example
+ * ```ts
+ * import { FileManager } from '@kubb/core'
+ *
+ * const manager = new FileManager()
+ * manager.upsert(myFile)
+ * console.log(manager.files) // all stored files
+ * ```
+ */
+declare class FileManager {
+  #private;
+  /**
+   * Adds one or more files. Files with the same path are merged — sources, imports,
+   * and exports from all calls with the same path are concatenated together.
+   */
+  add(...files: Array<FileNode>): Array<FileNode>;
+  /**
+   * Adds or merges one or more files.
+   * If a file with the same path already exists, its sources/imports/exports are merged together.
+   */
+  upsert(...files: Array<FileNode>): Array<FileNode>;
+  getByPath(path: string): FileNode | null;
+  deleteByPath(path: string): void;
+  clear(): void;
+  /**
+   * All stored files, sorted by path length (shorter paths first).
+   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+   */
+  get files(): Array<FileNode>;
+}
 //#endregion
 //#region src/PluginDriver.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
@@ -1728,7 +2048,7 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
   plugin: Plugin;
 };
 type Options = {
-  events: AsyncEventEmitter<KubbEvents>;
+  hooks?: AsyncEventEmitter<KubbHooks>;
   /**
    * @default Number.POSITIVE_INFINITY
    */
@@ -1772,7 +2092,54 @@ declare class PluginDriver {
   readonly fileManager: FileManager;
   readonly plugins: Map<string, Plugin>;
   constructor(config: Config, options: Options);
-  get events(): AsyncEventEmitter<KubbEvents>;
+  get hooks(): AsyncEventEmitter<KubbHooks>;
+  /**
+   * Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+   *
+   * For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
+   * plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
+   * `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
+   *
+   * All other hooks are iterated and registered directly as pass-through listeners.
+   * Any event key present in the global `KubbHooks` interface can be subscribed to.
+   *
+   * External tooling can subscribe to any of these events via `hooks.on(...)` to observe
+   * the plugin lifecycle without modifying plugin behavior.
+   */
+  registerPluginHooks(hookPlugin: HookStylePlugin, normalizedPlugin: Plugin): void;
+  /**
+   * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+   * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+   *
+   * Call this once from `safeBuild` before the plugin execution loop begins.
+   */
+  emitSetupHooks(): Promise<void>;
+  /**
+   * Registers a generator for the given plugin on the shared event emitter.
+   *
+   * The generator's `schema`, `operation`, and `operations` methods are registered as
+   * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+   * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+   * so that generators from different plugins do not cross-fire.
+   *
+   * The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
+   * Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
+   * declares a renderer.
+   *
+   * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
+   */
+  registerGenerator(pluginName: string, gen: Generator<any>): void;
+  /**
+   * Returns `true` when at least one generator was registered for the given plugin
+   * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+   *
+   * 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`.
+   */
+  hasRegisteredGenerators(pluginName: string): boolean;
+  dispose(): void;
+  setPluginResolver(pluginName: string, partial: Partial<Resolver>): void;
+  getResolver(pluginName: string): Resolver;
   getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
   /**
    * @deprecated use resolvers context instead
@@ -1843,7 +2210,7 @@ declare class PluginDriver {
     skipped?: ReadonlySet<Plugin> | null;
   }): SafeParseResult<H> | null;
   /**
-   * Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
+   * Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
    */
   hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
     hookName,
@@ -1853,7 +2220,7 @@ declare class PluginDriver {
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
   }): Promise<Awaited<TOutput>[]>;
   /**
-   * Chains plugins
+   * Execute a lifecycle hook sequentially for all plugins that implement it.
    */
   hookSeq<H extends PluginLifecycleHooks>({
     hookName,
@@ -1871,5 +2238,5 @@ declare class PluginDriver {
   requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
 }
 //#endregion
-export { FunctionParamsAST as $, Preset as A, Resolver as B, Plugin as C, PluginLifecycleHooks as D, PluginLifecycle as E, ResolveBannerContext as F, UserConfig as G, ResolverFileParams as H, ResolveNameParams as I, UserPlugin as J, UserGroup as K, ResolveOptionsContext as L, Printer$1 as M, PrinterFactoryOptions as N, PluginParameter as O, PrinterPartial as P, getBarrelFiles as Q, ResolvePathOptions as R, Override as S, PluginFactoryOptions as T, ResolverPathParams as U, ResolverContext as V, SchemaHook as W, UserResolver as X, UserPluginWithLifeCycle as Y, FileMetaBase as Z, LoggerContext as _, AdapterSource as a, defineParser as at, OperationsHook as b, Config as c, mergeGenerators as ct, GeneratorContext as d, formatters as dt, CLIOptions as et, Group as f, linters as ft, Logger as g, InputPath as h, AdapterFactoryOptions as i, Parser as it, Presets as j, PluginWithLifeCycle as k, DevtoolsOptions as l, Storage as lt, InputData as m, AsyncEventEmitter as mt, getMode as n, defineConfig as nt, BarrelType as o, Generator as ot, Include as p, logLevel as pt, UserLogger as q, Adapter as r, KubbEvents as rt, CompatibilityPreset as s, defineGenerator as st, PluginDriver as t, ConfigInput as tt, Exclude as u, createStorage as ut, LoggerOptions as v, PluginContext as w, Output as x, OperationHook as y, ResolvePathParams as z };
-//# sourceMappingURL=PluginDriver-BBi_41VF.d.ts.map
+export { FileMetaBase as $, Override as A, ResolveNameParams as B, KubbPluginSetupContext as C, OperationHook as D, LoggerOptions as E, PluginLifecycleHooks as F, ResolverContext as G, ResolvePathOptions as H, PluginParameter as I, SchemaHook as J, ResolverFileParams as K, PluginWithLifeCycle as L, PluginContext as M, PluginFactoryOptions as N, OperationsHook as O, PluginLifecycle as P, UserPluginWithLifeCycle as Q, PossibleConfig as R, KubbBuildStartContext as S, LoggerContext as T, ResolvePathParams as U, ResolveOptionsContext as V, Resolver as W, UserLogger as X, UserGroup as Y, UserPlugin as Z, Group as _, RendererFactory as _t, defineGenerator as a, Kubb$1 as at, InputPath as b, AdapterSource as c, createKubb as ct, CompatibilityPreset as d, Storage as dt, getBarrelFiles as et, Config as f, createStorage as ft, GeneratorContext as g, Renderer as gt, Exclude$1 as h, logLevel as ht, Generator as i, definePlugin as it, Plugin as j, Output as k, BarrelType as l, Parser as lt, DevtoolsOptions as m, linters as mt, getMode as n, HookStylePlugin as nt, Adapter as o, KubbHooks as ot, ConfigInput as p, formatters as pt, ResolverPathParams as q, FileManager as r, PluginHooks as rt, AdapterFactoryOptions as s, BuildOutput as st, PluginDriver as t, FunctionParamsAST as tt, CLIOptions as u, defineParser as ut, Include as v, createRenderer as vt, Logger as w, KubbBuildEndContext as x, InputData as y, AsyncEventEmitter as yt, ResolveBannerContext as z };
+//# sourceMappingURL=PluginDriver-C9iBgYbk.d.ts.map