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

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

@@ -94,6 +94,25 @@ declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[
  */
 type PossiblePromise<T> = Promise<T> | T;
 //#endregion
+//#region src/constants.d.ts
+/**
+ * Base URL for the Kubb Studio web app.
+ */
+declare const DEFAULT_STUDIO_URL: "https://studio.kubb.dev";
+/**
+ * Numeric log-level thresholds used internally to compare verbosity.
+ *
+ * Higher numbers are more verbose.
+ */
+declare const logLevel: {
+  readonly silent: number;
+  readonly error: 0;
+  readonly warn: 1;
+  readonly info: 3;
+  readonly verbose: 4;
+  readonly debug: 5;
+};
+//#endregion
 //#region src/createRenderer.d.ts
 /**
  * Minimal interface any Kubb renderer must satisfy.
@@ -147,73 +166,6 @@ type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
  */
 declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
 //#endregion
-//#region src/constants.d.ts
-/**
- * Base URL for the Kubb Studio web app.
- */
-declare const DEFAULT_STUDIO_URL: "https://studio.kubb.dev";
-/**
- * Numeric log-level thresholds used internally to compare verbosity.
- *
- * Higher numbers are more verbose.
- */
-declare const logLevel: {
-  readonly silent: number;
-  readonly error: 0;
-  readonly warn: 1;
-  readonly info: 3;
-  readonly verbose: 4;
-  readonly debug: 5;
-};
-/**
- * CLI command descriptors for each supported linter.
- *
- * Each entry contains the executable `command`, an `args` factory that maps an
- * output path to the correct argument list, and an `errorMessage` shown when
- * the linter is not found.
- */
-declare const linters: {
-  readonly eslint: {
-    readonly command: "eslint";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Eslint not found";
-  };
-  readonly biome: {
-    readonly command: "biome";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Biome not found";
-  };
-  readonly oxlint: {
-    readonly command: "oxlint";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Oxlint not found";
-  };
-};
-/**
- * CLI command descriptors for each supported code formatter.
- *
- * Each entry contains the executable `command`, an `args` factory that maps an
- * output path to the correct argument list, and an `errorMessage` shown when
- * the formatter is not found.
- */
-declare const formatters: {
-  readonly prettier: {
-    readonly command: "prettier";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Prettier not found";
-  };
-  readonly biome: {
-    readonly command: "biome";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Biome not found";
-  };
-  readonly oxfmt: {
-    readonly command: "oxfmt";
-    readonly args: (outputPath: string) => string[];
-    readonly errorMessage: "Oxfmt not found";
-  };
-};
-//#endregion
 //#region src/createStorage.d.ts
 type Storage = {
   /**
@@ -271,6 +223,90 @@ 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 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/defineParser.d.ts
 type PrintOptions = {
   extname?: FileNode['extname'];
@@ -312,213 +348,533 @@ type Parser<TMeta extends object = any> = {
  */
 declare function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta>;
 //#endregion
-//#region src/createKubb.d.ts
+//#region src/definePlugin.d.ts
 /**
- * Full output produced by a successful or failed build.
+ * 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 BuildOutput = {
+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> = {
   /**
-   * Plugins that threw during installation, paired with the caught error.
+   * Unique name for the plugin, following the same naming convention as `createPlugin`.
    */
-  failedPlugins: Set<{
-    plugin: Plugin;
-    error: Error;
-  }>;
-  files: Array<FileNode>;
-  driver: PluginDriver;
+  name: string;
   /**
-   * Elapsed time in milliseconds for each plugin, keyed by plugin name.
+   * Plugins that must be registered before this plugin executes.
+   * An error is thrown at startup when any listed dependency is missing.
    */
-  pluginTimings: Map<string, number>;
-  error?: Error;
+  dependencies?: Array<string>;
   /**
-   * Raw generated source, keyed by absolute file path.
+   * The options passed by the user when calling the plugin factory.
    */
-  sources: Map<string, string>;
-};
-type KubbOptions = {
-  config: Config;
-  hooks?: AsyncEventEmitter<KubbHooks>;
+  options?: TFactory['options'];
+  /**
+   * Lifecycle event handlers for this plugin.
+   * Any event from the global `KubbHooks` map can be subscribed to here.
+   */
+  hooks: PluginHooks<TFactory>;
 };
 /**
- * Creates a Kubb instance bound to a single config entry.
+ * Creates a plugin factory using the new hook-style (`hooks:`) API.
  *
- * 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()`.
+ * 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
  * ```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()
+ * // 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>
+ *     },
+ *   },
+ * }))
  * ```
  */
-declare function createKubb(options: KubbOptions): Kubb$1;
+declare function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(factory: (options: TFactory['options']) => HookStylePlugin<TFactory>): (options?: TFactory['options']) => HookStylePlugin<TFactory>;
 //#endregion
-//#region src/Kubb.d.ts
-type DebugInfo = {
-  date: Date;
-  logs: Array<string>;
-  fileName?: string;
-};
-type HookProgress<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  hookName: H;
-  plugins: Array<Plugin>;
-};
-type HookExecution<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  strategy: Strategy;
-  hookName: H;
-  plugin: Plugin;
-  parameters?: Array<unknown>;
-  output?: unknown;
-};
-type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  duration: number;
-  strategy: Strategy;
-  hookName: H;
-  plugin: Plugin;
-  parameters?: Array<unknown>;
-  output?: unknown;
-};
+//#region src/FileManager.d.ts
 /**
- * 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;
+ * 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;
   /**
-   * The resolved config with applied defaults. Available after `setup()` has been called.
+   * 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.
    */
-  readonly config: Config | undefined;
+  add(...files: Array<FileNode>): Array<FileNode>;
   /**
-   * 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.
+   * Adds or merges one or more files.
+   * If a file with the same path already exists, its sources/imports/exports are merged together.
    */
-  setup(): Promise<void>;
+  upsert(...files: Array<FileNode>): Array<FileNode>;
+  getByPath(path: string): FileNode | null;
+  deleteByPath(path: string): void;
+  clear(): void;
   /**
-   * Runs a full Kubb build and throws on any error or plugin failure.
-   * Automatically calls `setup()` if it has not been called yet.
+   * All stored files, sorted by path length (shorter paths first).
+   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
    */
-  build(): Promise<BuildOutput>;
+  get files(): Array<FileNode>;
+}
+//#endregion
+//#region src/PluginDriver.d.ts
+type RequiredPluginLifecycle = Required<PluginLifecycle>;
+/**
+ * Hook dispatch strategy used by the `PluginDriver`.
+ *
+ * - `hookFirst` — stops at the first non-null result.
+ * - `hookForPlugin` — calls only the matching plugin.
+ * - `hookParallel` — calls all plugins concurrently.
+ * - `hookSeq` — calls all plugins in order, threading the result.
+ */
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+  result: Result;
+  plugin: Plugin;
+};
+type Options = {
+  hooks?: AsyncEventEmitter<KubbHooks>;
   /**
-   * Runs a full Kubb build and captures errors instead of throwing.
-   * Automatically calls `setup()` if it has not been called yet.
+   * @default Number.POSITIVE_INFINITY
    */
-  safeBuild(): Promise<BuildOutput>;
+  concurrency?: number;
 };
 /**
- * Events emitted during the Kubb code generation lifecycle.
- * These events can be listened to for logging, progress tracking, and custom integrations.
- *
- * @example
- * ```typescript
- * import type { AsyncEventEmitter } from '@internals/utils'
- * import type { KubbHooks } from '@kubb/core'
- *
- * const hooks: AsyncEventEmitter<KubbHooks> = new AsyncEventEmitter()
- *
- * hooks.on('kubb:lifecycle:start', () => {
- *   console.log('Starting Kubb generation')
- * })
- *
- * hooks.on('kubb:plugin:end', (plugin, { duration }) => {
- *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
- * })
- * ```
+ * Parameters accepted by `PluginDriver.getFile` to resolve a generated file descriptor.
  */
-interface KubbHooks {
+type GetFileOptions<TOptions = object> = {
+  name: string;
+  mode?: 'single' | 'split';
+  extname: FileNode['extname'];
+  pluginName: string;
+  options?: TOptions;
+};
+declare class PluginDriver {
+  #private;
+  readonly config: Config;
+  readonly options: Options;
   /**
-   * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
+   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+   *
+   * @example
+   * ```ts
+   * PluginDriver.getMode('src/gen/types.ts')  // 'single'
+   * PluginDriver.getMode('src/gen/types')     // 'split'
+   * ```
    */
-  'kubb:lifecycle:start': [version: string];
+  static getMode(fileOrFolder: string | undefined | null): 'single' | 'split';
   /**
-   * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
+   * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
+   * the build pipeline after the adapter's `parse()` resolves.
    */
-  'kubb:lifecycle:end': [];
+  inputNode: InputNode | undefined;
+  adapter: Adapter | undefined;
   /**
-   * Emitted when configuration loading starts.
+   * Central file store for all generated files.
+   * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+   * add files; this property gives direct read/write access when needed.
    */
-  'kubb:config:start': [];
+  readonly fileManager: FileManager;
+  readonly plugins: Map<string, Plugin>;
+  constructor(config: Config, options: Options);
+  get hooks(): AsyncEventEmitter<KubbHooks>;
   /**
-   * Emitted when configuration loading is complete.
+   * 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.
    */
-  'kubb:config:end': [configs: Array<Config>];
+  registerPluginHooks(hookPlugin: HookStylePlugin, normalizedPlugin: Plugin): void;
   /**
-   * Emitted when code generation phase starts.
+   * 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.
    */
-  'kubb:generation:start': [config: Config];
+  emitSetupHooks(): Promise<void>;
   /**
-   * Emitted when code generation phase completes.
+   * 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.
    */
-  'kubb:generation:end': [config: Config, files: Array<FileNode>, sources: Map<string, string>];
+  registerGenerator(pluginName: string, gen: Generator): void;
   /**
-   * Emitted with a summary of the generation results.
-   * Contains summary lines, title, and success status.
+   * 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`.
    */
-  'kubb:generation:summary': [config: Config, {
-    failedPlugins: Set<{
-      plugin: Plugin;
-      error: Error;
-    }>;
-    status: 'success' | 'failed';
-    hrStart: [number, number];
-    filesCreated: number;
-    pluginTimings?: Map<Plugin['name'], number>;
-  }];
+  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>;
   /**
-   * Emitted when code formatting starts (e.g., running Biome or Prettier).
+   * @deprecated use resolvers context instead
    */
-  'kubb:format:start': [];
+  getFile<TOptions = object>({
+    name,
+    mode,
+    extname,
+    pluginName,
+    options
+  }: GetFileOptions<TOptions>): FileNode<{
+    pluginName: string;
+  }>;
   /**
-   * Emitted when code formatting completes.
+   * @deprecated use resolvers context instead
    */
-  'kubb:format:end': [];
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => string;
   /**
-   * Emitted when linting starts.
+   * @deprecated use resolvers context instead
    */
-  'kubb:lint:start': [];
+  resolveName: (params: ResolveNameParams) => string;
   /**
-   * Emitted when linting completes.
+   * Run a specific hookName for plugin x.
    */
-  'kubb:lint:end': [];
+  hookForPlugin<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
   /**
-   * Emitted when plugin hooks execution starts.
+   * Run a specific hookName for plugin x.
    */
-  'kubb:hooks:start': [];
+  hookForPluginSync<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Array<ReturnType<ParseResult<H>>> | null;
   /**
-   * Emitted when plugin hooks execution completes.
+   * Returns the first non-null result.
    */
-  'kubb:hooks:end': [];
+  hookFirst<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): Promise<SafeParseResult<H>>;
   /**
-   * Emitted when a single hook execution starts (e.g., format or lint).
-   * The callback should be invoked when the command completes.
+   * Returns the first non-null result.
    */
-  'kubb:hook:start': [{
-    id?: string;
-    command: string;
-    args?: readonly string[];
-  }];
+  hookFirstSync<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): SafeParseResult<H> | null;
   /**
-   * Emitted when a single hook execution completes.
+   * Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
+   */
+  hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+  }): Promise<Awaited<TOutput>[]>;
+  /**
+   * Execute a lifecycle hook sequentially for all plugins that implement it.
+   */
+  hookSeq<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: PluginParameter<H>;
+  }): Promise<void>;
+  getPlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
+  getPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions> | undefined;
+  /**
+   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
+   */
+  requirePlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]>;
+  requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
+}
+//#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;
+  logs: Array<string>;
+  fileName?: string;
+};
+type HookProgress<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H;
+  plugins: Array<Plugin>;
+};
+type HookExecution<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: Array<unknown>;
+  output?: unknown;
+};
+type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  duration: number;
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  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.
+ *
+ * @example
+ * ```typescript
+ * import type { AsyncEventEmitter } from '@internals/utils'
+ * import type { KubbHooks } from '@kubb/core'
+ *
+ * const hooks: AsyncEventEmitter<KubbHooks> = new AsyncEventEmitter()
+ *
+ * hooks.on('kubb:lifecycle:start', () => {
+ *   console.log('Starting Kubb generation')
+ * })
+ *
+ * hooks.on('kubb:plugin:end', (plugin, { duration }) => {
+ *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
+ * })
+ * ```
+ */
+interface KubbHooks {
+  /**
+   * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
+   */
+  'kubb:lifecycle:start': [version: string];
+  /**
+   * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
+   */
+  'kubb:lifecycle:end': [];
+  /**
+   * Emitted when configuration loading starts.
+   */
+  'kubb:config:start': [];
+  /**
+   * Emitted when configuration loading is complete.
+   */
+  'kubb:config:end': [configs: Array<Config>];
+  /**
+   * Emitted when code generation phase starts.
+   */
+  'kubb:generation:start': [config: Config];
+  /**
+   * Emitted when code generation phase completes.
+   */
+  '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.
+   */
+  'kubb:generation:summary': [config: Config, {
+    failedPlugins: Set<{
+      plugin: Plugin;
+      error: Error;
+    }>;
+    status: 'success' | 'failed';
+    hrStart: [number, number];
+    filesCreated: number;
+    pluginTimings?: Map<Plugin['name'], number>;
+  }];
+  /**
+   * Emitted when code formatting starts (e.g., running Biome or Prettier).
+   */
+  'kubb:format:start': [];
+  /**
+   * Emitted when code formatting completes.
+   */
+  'kubb:format:end': [];
+  /**
+   * Emitted when linting starts.
+   */
+  'kubb:lint:start': [];
+  /**
+   * Emitted when linting completes.
+   */
+  'kubb:lint:end': [];
+  /**
+   * Emitted when plugin hooks execution starts.
+   */
+  'kubb:hooks:start': [];
+  /**
+   * Emitted when plugin hooks execution completes.
+   */
+  'kubb:hooks:end': [];
+  /**
+   * Emitted when a single hook execution starts (e.g., format or lint).
+   * The callback should be invoked when the command completes.
+   */
+  'kubb:hook:start': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+  }];
+  /**
+   * Emitted when a single hook execution completes.
    */
   'kubb:hook:end': [{
     id?: string;
@@ -691,164 +1047,25 @@ declare global {
   }
 }
 //#endregion
-//#region src/definePlugin.d.ts
-/**
- * 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 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> = {
-  /**
-   * Unique name for the plugin, following the same naming convention as `createPlugin`.
-   */
-  name: string;
-  /**
-   * Plugins that must be registered before this plugin executes.
-   * An error is thrown at startup when any listed dependency is missing.
-   */
-  dependencies?: Array<string>;
-  /**
-   * The options passed by the user when calling the plugin factory.
-   */
-  options?: TFactory['options'];
-  /**
-   * Lifecycle event handlers for this plugin.
-   * Any event from the global `KubbHooks` map can be subscribed to here.
-   */
-  hooks: PluginHooks<TFactory>;
-};
-/**
- * Creates a plugin factory using the new hook-style (`hooks:`) API.
- *
- * 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
- * ```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>
- *     },
- *   },
- * }))
- * ```
- */
-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 = {
-  name?: string;
-  type?: string;
-  /**
-   * @default true
-   */
-  required?: boolean;
-  /**
-   * @default true
-   */
-  enabled?: boolean;
-  default?: string;
-};
-type FunctionParamsASTWithType = {
-  name?: never;
-  type: string;
-  /**
-   * @default true
-   */
-  required?: boolean;
-  /**
-   * @default true
-   */
-  enabled?: boolean;
-  default?: string;
-};
-/**
- * @deprecated use ast package instead
- */
-type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
-//#endregion
-//#region src/utils/getBarrelFiles.d.ts
-type FileMetaBase = {
-  pluginName?: string;
-};
-type AddIndexesProps = {
-  type: BarrelType | false | undefined;
-  /**
-   * Absolute output root derived from config `root` and `output.path`.
-   */
-  root: string;
-  /**
-   * Output settings for the plugin.
-   */
-  output: {
-    path: string;
-  };
-  group?: {
-    output: string;
-    exportAs: string;
-  };
-  meta?: FileMetaBase;
-};
-/**
- * Generates `index.ts` barrel files for all directories under `root/output.path`.
- *
- * - Returns an empty array when `type` is falsy or `'propagate'`.
- * - Skips generation when the output path itself ends with `index` (already a barrel).
- * - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
- * - Attaches `meta` to each barrel file for downstream plugin identification.
- */
-declare function getBarrelFiles(files: Array<FileNode>, {
-  type,
-  meta,
-  root,
-  output
-}: AddIndexesProps): Promise<Array<FileNode>>;
-//#endregion
-//#region src/types.d.ts
-type InputPath = {
-  /**
-   * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
-   */
-  path: string;
-};
-type InputData = {
-  /**
-   * A `string` or `object` that contains your Swagger/OpenAPI data.
-   */
-  data: string | unknown;
-};
-type Input = InputPath | InputData;
+//#region src/utils/getBarrelFiles.d.ts
+type FileMetaBase = {
+  pluginName?: string;
+};
+//#endregion
+//#region src/types.d.ts
+type InputPath = {
+  /**
+   * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
+   */
+  path: string;
+};
+type InputData = {
+  /**
+   * A `string` or `object` that contains your Swagger/OpenAPI data.
+   */
+  data: string | unknown;
+};
+type Input = InputPath | InputData;
 /**
  * The raw source passed to an adapter's `parse` function.
  * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
@@ -1249,7 +1466,7 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
    * 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>>;
+  generators?: Array<Generator>;
   /**
    * 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.
@@ -1352,7 +1569,7 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
    * 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>>;
+  generators?: Array<Generator>;
   buildStart: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
    * Called once per plugin after all files have been written to disk.
@@ -1488,7 +1705,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   /**
    * Returns the output mode for the given output config.
    * Returns `'single'` when `output.path` has a file extension, `'split'` otherwise.
-   * Shorthand for `getMode(path.resolve(this.root, output.path))`.
+   * Shorthand for `PluginDriver.getMode(path.resolve(this.root, output.path))`.
    */
   getMode: (output: {
     path: string;
@@ -1902,341 +2119,6 @@ type CLIOptions = {
  * - `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>;
-/**
- * Hook dispatch strategy used by the `PluginDriver`.
- *
- * - `hookFirst` — stops at the first non-null result.
- * - `hookForPlugin` — calls only the matching plugin.
- * - `hookParallel` — calls all plugins concurrently.
- * - `hookSeq` — calls all plugins in order, threading the result.
- */
-type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
-type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
-type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
-  result: Result;
-  plugin: Plugin;
-};
-type Options = {
-  hooks?: AsyncEventEmitter<KubbHooks>;
-  /**
-   * @default Number.POSITIVE_INFINITY
-   */
-  concurrency?: number;
-};
-/**
- * Parameters accepted by `PluginDriver.getFile` to resolve a generated file descriptor.
- */
-type GetFileOptions<TOptions = object> = {
-  name: string;
-  mode?: 'single' | 'split';
-  extname: FileNode['extname'];
-  pluginName: string;
-  options?: TOptions;
-};
-/**
- * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
- *
- * @example
- * ```ts
- * getMode('src/gen/types.ts')  // 'single'
- * getMode('src/gen/types')     // 'split'
- * ```
- */
-declare function getMode(fileOrFolder: string | undefined | null): 'single' | 'split';
-declare class PluginDriver {
-  #private;
-  readonly config: Config;
-  readonly options: Options;
-  /**
-   * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
-   * the build pipeline after the adapter's `parse()` resolves.
-   */
-  inputNode: InputNode | undefined;
-  adapter: Adapter | undefined;
-  /**
-   * Central file store for all generated files.
-   * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
-   * add files; this property gives direct read/write access when needed.
-   */
-  readonly fileManager: FileManager;
-  readonly plugins: Map<string, Plugin>;
-  constructor(config: Config, options: Options);
-  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
-   */
-  getFile<TOptions = object>({
-    name,
-    mode,
-    extname,
-    pluginName,
-    options
-  }: GetFileOptions<TOptions>): FileNode<{
-    pluginName: string;
-  }>;
-  /**
-   * @deprecated use resolvers context instead
-   */
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => string;
-  /**
-   * @deprecated use resolvers context instead
-   */
-  resolveName: (params: ResolveNameParams) => string;
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPlugin<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters
-  }: {
-    pluginName: string;
-    hookName: H;
-    parameters: PluginParameter<H>;
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPluginSync<H extends PluginLifecycleHooks>({
-    pluginName,
-    hookName,
-    parameters
-  }: {
-    pluginName: string;
-    hookName: H;
-    parameters: PluginParameter<H>;
-  }): Array<ReturnType<ParseResult<H>>> | null;
-  /**
-   * Returns the first non-null result.
-   */
-  hookFirst<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped
-  }: {
-    hookName: H;
-    parameters: PluginParameter<H>;
-    skipped?: ReadonlySet<Plugin> | null;
-  }): Promise<SafeParseResult<H>>;
-  /**
-   * Returns the first non-null result.
-   */
-  hookFirstSync<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    skipped
-  }: {
-    hookName: H;
-    parameters: PluginParameter<H>;
-    skipped?: ReadonlySet<Plugin> | null;
-  }): SafeParseResult<H> | null;
-  /**
-   * Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
-   */
-  hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
-    hookName,
-    parameters
-  }: {
-    hookName: H;
-    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
-  }): Promise<Awaited<TOutput>[]>;
-  /**
-   * Execute a lifecycle hook sequentially for all plugins that implement it.
-   */
-  hookSeq<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters
-  }: {
-    hookName: H;
-    parameters?: PluginParameter<H>;
-  }): Promise<void>;
-  getPlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
-  getPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions> | undefined;
-  /**
-   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
-   */
-  requirePlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]>;
-  requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
-}
 //#endregion
-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
+export { FileManager as $, PluginParameter as A, ResolverFileParams as B, Output as C, PluginFactoryOptions as D, PluginContext as E, ResolveOptionsContext as F, UserPlugin as G, SchemaHook as H, ResolvePathOptions as I, Kubb$1 as J, UserPluginWithLifeCycle as K, ResolvePathParams as L, PossibleConfig as M, ResolveBannerContext as N, PluginLifecycle as O, ResolveNameParams as P, PluginDriver as Q, Resolver as R, OperationsHook as S, Plugin as T, UserGroup as U, ResolverPathParams as V, UserLogger as W, BuildOutput as X, KubbHooks as Y, createKubb as Z, KubbPluginSetupContext as _, CLIOptions as a, Generator as at, LoggerOptions as b, DevtoolsOptions as c, createStorage as ct, Group as d, createRenderer as dt, HookStylePlugin as et, Include as f, logLevel as ft, KubbBuildStartContext as g, KubbBuildEndContext as h, BarrelType as i, defineParser as it, PluginWithLifeCycle as j, PluginLifecycleHooks as k, Exclude$1 as l, Renderer as lt, InputPath as m, AdapterFactoryOptions as n, definePlugin as nt, CompatibilityPreset as o, defineGenerator as ot, InputData as p, AsyncEventEmitter as pt, FileMetaBase as q, AdapterSource as r, Parser as rt, Config as s, Storage as st, Adapter as t, PluginHooks as tt, GeneratorContext as u, RendererFactory as ut, Logger as v, Override as w, OperationHook as x, LoggerContext as y, ResolverContext as z };
+//# sourceMappingURL=types-DUc5lEUp.d.ts.map