@kubb/core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/{types-B7eZvqwD.d.ts → PluginDriver-CEQPafXV.d.ts}

@@ -1,100 +1,102 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { EventEmitter } from "node:events";
-import { Fabric } from "@kubb/react-fabric";
-import { KubbFile } from "@kubb/fabric-core/types";
-import { Printer, PrinterFactoryOptions, RootNode } from "@kubb/ast/types";
+import { Node, OperationNode, Printer, PrinterFactoryOptions, RootNode, SchemaNode, Visitor } from "@kubb/ast/types";
+import { Fabric, KubbFile } from "@kubb/fabric-core/types";
+import { HttpMethod } from "@kubb/oas";
+import { FabricReactNode } from "@kubb/react-fabric/types";
 
-//#region ../../internals/utils/dist/index.d.ts
-/**
-* A typed EventEmitter that awaits all async listeners before resolving.
-* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
-*/
-declare var AsyncEventEmitter: {
-  new (maxListener?: number): {
-    "__#private@#emitter": EventEmitter<[never]>;
-    /**
-    * Emits an event and awaits all registered listeners in parallel.
-    * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-    */
-    emit(eventName: any, ...eventArgs: any[]): Promise<void>; /** Registers a persistent listener for the given event. */
-    on(eventName: any, handler: any): void; /** Registers a one-shot listener that removes itself after the first invocation. */
-    onOnce(eventName: any, handler: any): void; /** Removes a previously registered listener. */
-    off(eventName: any, handler: any): void; /** Removes all listeners from every event channel. */
-    removeAll(): void;
-  };
-};
+//#region ../../internals/utils/src/asyncEventEmitter.d.ts
 /**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
-*/
-declare var URLPath: {
-  new (path: any, options?: {}): {
-    /** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */path: any;
-    "__#private@#options": {}; /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
-    get URL(): any; /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
-    get isURL(): boolean;
-    /**
-    * Converts the OpenAPI path to a TypeScript template literal string.
-    *
-    * @example
-    * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-    * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-    */
-    get template(): string; /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
-    get object(): string | {
-      url: any;
-      params: {} | undefined;
-    }; /** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
-    get params(): {} | undefined;
-    "__#private@#transformParam"(raw: any): any; /** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
-    "__#private@#eachParam"(fn: any): void;
-    toObject({
-      type,
-      replacer,
-      stringify
-    }?: {
-      type?: string | undefined;
-    }): string | {
-      url: any;
-      params: {} | undefined;
-    };
-    /**
-    * Converts the OpenAPI path to a TypeScript template literal string.
-    * An optional `replacer` can transform each extracted parameter name before interpolation.
-    *
-    * @example
-    * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-    */
-    toTemplateString({
-      prefix,
-      replacer
-    }?: {
-      prefix?: string | undefined;
-    }): string;
-    /**
-    * Extracts all `{param}` segments from the path and returns them as a key-value map.
-    * An optional `replacer` transforms each parameter name in both key and value positions.
-    * Returns `undefined` when no path parameters are found.
-    */
-    getParams(replacer: any): {} | undefined; /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
-    toURLPath(): any;
-  };
-};
+ * A function that can be registered as an event listener, synchronous or async.
+ */
+type AsyncListener<TArgs extends unknown[]> = (...args: TArgs) => void | Promise<void>;
 /**
-* Serializes a primitive value to a JSON string literal, stripping any surrounding quote characters first.
-*
-* @example
-* stringify('hello')   // '"hello"'
-* stringify('"hello"') // '"hello"'
-*/
-declare function stringify(value: any): string;
+ * Typed `EventEmitter` that awaits all async listeners before resolving.
+ * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+ *
+ * @example
+ * ```ts
+ * const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
+ * emitter.on('build', async (name) => { console.log(name) })
+ * await emitter.emit('build', 'petstore') // all listeners awaited
+ * ```
+ */
+declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[] }> {
+  #private;
+  /**
+   * Maximum number of listeners per event before Node emits a memory-leak warning.
+   * @default 10
+   */
+  constructor(maxListener?: number);
+  /**
+   * Emits `eventName` and awaits all registered listeners in parallel.
+   * Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+   *
+   * @example
+   * ```ts
+   * await emitter.emit('build', 'petstore')
+   * ```
+   */
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
+  /**
+   * Registers a persistent listener for `eventName`.
+   *
+   * @example
+   * ```ts
+   * emitter.on('build', async (name) => { console.log(name) })
+   * ```
+   */
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /**
+   * Registers a one-shot listener that removes itself after the first invocation.
+   *
+   * @example
+   * ```ts
+   * emitter.onOnce('build', async (name) => { console.log(name) })
+   * ```
+   */
+  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /**
+   * Removes a previously registered listener.
+   *
+   * @example
+   * ```ts
+   * emitter.off('build', handler)
+   * ```
+   */
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: AsyncListener<TEvents[TEventName]>): void;
+  /**
+   * Removes all listeners from every event channel.
+   *
+   * @example
+   * ```ts
+   * emitter.removeAll()
+   * ```
+   */
+  removeAll(): void;
+}
+//#endregion
+//#region ../../internals/utils/src/promise.d.ts
+/** A value that may already be resolved or still pending.
+ *
+ * @example
+ * ```ts
+ * function load(id: string): PossiblePromise<string> {
+ *   return cache.get(id) ?? fetchRemote(id)
+ * }
+ * ```
+ */
+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;
@@ -103,6 +105,13 @@ declare const logLevel: {
   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";
@@ -120,6 +129,13 @@ declare const linters: {
     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";
@@ -138,46 +154,46 @@ declare const formatters: {
   };
 };
 //#endregion
-//#region src/defineStorage.d.ts
-/**
- * Storage interface for persisting Kubb output.
- *
- * Keys are root-relative forward-slash paths (e.g. `src/gen/api/getPets.ts`).
- * Implement this interface to route generated files to any backend — filesystem,
- * S3, Redis, in-memory, etc.
- *
- * Use `defineStorage` to create a typed storage driver.
- */
-interface DefineStorage {
-  /** Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`). */
+//#region src/createStorage.d.ts
+type Storage = {
+  /**
+   * Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`).
+   */
   readonly name: string;
-  /** Returns `true` when an entry for `key` exists in storage. */
+  /**
+   * Returns `true` when an entry for `key` exists in storage.
+   */
   hasItem(key: string): Promise<boolean>;
-  /** Returns the stored string value, or `null` when `key` does not exist. */
+  /**
+   * Returns the stored string value, or `null` when `key` does not exist.
+   */
   getItem(key: string): Promise<string | null>;
-  /** Persists `value` under `key`, creating any required structure. */
+  /**
+   * Persists `value` under `key`, creating any required structure.
+   */
   setItem(key: string, value: string): Promise<void>;
-  /** Removes the entry for `key`. No-ops when the key does not exist. */
+  /**
+   *  Removes the entry for `key`. No-ops when the key does not exist.
+   */
   removeItem(key: string): Promise<void>;
-  /** Returns all keys, optionally filtered to those starting with `base`. */
+  /**
+   * Returns all keys, optionally filtered to those starting with `base`.
+   */
   getKeys(base?: string): Promise<Array<string>>;
-  /** Removes all entries, optionally scoped to those starting with `base`. */
+  /**
+   * Removes all entries, optionally scoped to those starting with `base`.
+   */
   clear(base?: string): Promise<void>;
-  /** Optional teardown hook called after the build completes. */
+  /**
+   * Optional teardown hook called after the build completes.
+   */
   dispose?(): Promise<void>;
-}
+};
 /**
- * Wraps a storage builder so the `options` argument is optional, following the
- * same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
- *
- * The builder receives the resolved options object and must return a
- * `DefineStorage`-compatible object that includes a `name` string.
+ * Creates a storage factory. Call the returned function with optional options to get the storage instance.
  *
  * @example
- * ```ts
- * import { defineStorage } from '@kubb/core'
- *
- * export const memoryStorage = defineStorage((_options) => {
+ * export const memoryStorage = createStorage(() => {
  *   const store = new Map<string, string>()
  *   return {
  *     name: 'memory',
@@ -185,160 +201,127 @@ interface DefineStorage {
  *     async getItem(key) { return store.get(key) ?? null },
  *     async setItem(key, value) { store.set(key, value) },
  *     async removeItem(key) { store.delete(key) },
- *     async getKeys() { return [...store.keys()] },
- *     async clear() { store.clear() },
+ *     async getKeys(base) {
+ *       const keys = [...store.keys()]
+ *       return base ? keys.filter((k) => k.startsWith(base)) : keys
+ *     },
+ *     async clear(base) { if (!base) store.clear() },
  *   }
  * })
- * ```
  */
-declare function defineStorage<TOptions = Record<string, never>>(build: (options: TOptions) => DefineStorage): (options?: TOptions) => DefineStorage;
+declare function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage;
 //#endregion
-//#region src/PluginManager.d.ts
-type RequiredPluginLifecycle = Required<PluginLifecycle>;
-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;
+//#region src/defineGenerator.d.ts
+/**
+ * Props for the `operations` lifecycle — receives all operation nodes at once.
+ */
+type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  plugin: Plugin<TPlugin>;
+  adapter: Adapter;
+  options: Plugin<TPlugin>['options'];
+  nodes: Array<OperationNode>;
 };
-type Options = {
-  fabric: Fabric;
-  events: AsyncEventEmitter<KubbEvents>;
-  /**
-   * @default Number.POSITIVE_INFINITY
-   */
-  concurrency?: number;
+/**
+ * Props for the `operation` lifecycle — receives a single operation node.
+ */
+type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  plugin: Plugin<TPlugin>;
+  options: Plugin<TPlugin>['options'];
+  node: OperationNode;
 };
-type GetFileProps<TOptions = object> = {
+/**
+ * Props for the `schema` lifecycle — receives a single schema node.
+ */
+type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  plugin: Plugin<TPlugin>;
+  options: Plugin<TPlugin>['options'];
+  node: SchemaNode;
+};
+type UserCoreGeneratorV2<TPlugin extends PluginFactoryOptions> = {
   name: string;
-  mode?: KubbFile.Mode;
-  extname: KubbFile.Extname;
-  pluginName: string;
-  options?: TOptions;
+  type: 'core';
+  version?: '2';
+  operations?(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
+  operation?(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
+  schema?(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
 };
-declare function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode;
-declare class PluginManager {
-  #private;
-  readonly config: Config;
-  readonly options: Options;
-  /**
-   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
-   * the build pipeline after the adapter's `parse()` resolves.
-   */
-  rootNode: RootNode | undefined;
-  constructor(config: Config, options: Options);
-  get events(): AsyncEventEmitter<KubbEvents>;
-  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
-  get plugins(): Array<Plugin>;
-  getFile<TOptions = object>({
-    name,
-    mode,
-    extname,
-    pluginName,
-    options
-  }: GetFileProps<TOptions>): KubbFile.File<{
-    pluginName: string;
-  }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
-  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 `pre`/`post` settings.
-   */
-  hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
-    hookName,
-    parameters
-  }: {
-    hookName: H;
-    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
-  }): Promise<Awaited<TOutput>[]>;
-  /**
-   * Chains plugins
-   */
-  hookSeq<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters
-  }: {
-    hookName: H;
-    parameters?: PluginParameter<H>;
-  }): Promise<void>;
-  getPluginByName(pluginName: string): Plugin | undefined;
-  getPluginsByName(hookName: keyof PluginWithLifeCycle, pluginName: string): Plugin[];
-}
+type UserReactGeneratorV2<TPlugin extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  version?: '2';
+  Operations?(props: OperationsV2Props<TPlugin>): FabricReactNode;
+  Operation?(props: OperationV2Props<TPlugin>): FabricReactNode;
+  Schema?(props: SchemaV2Props<TPlugin>): FabricReactNode;
+};
+type CoreGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  version: '2';
+  operations(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
+  operation(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
+  schema(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>;
+};
+type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  version: '2';
+  Operations(props: OperationsV2Props<TPlugin>): FabricReactNode;
+  Operation(props: OperationV2Props<TPlugin>): FabricReactNode;
+  Schema(props: SchemaV2Props<TPlugin>): FabricReactNode;
+};
+type Generator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>;
+/**
+ * Defines a generator with no-op defaults for any omitted lifecycle methods.
+ * Works for both `core` (async file output) and `react` (JSX component) generators.
+ *
+ * @example
+ * // react generator
+ * export const typeGenerator = defineGenerator<PluginTs>({
+ *   name: 'typescript',
+ *   type: 'react',
+ *   Operation({ node, options }) { return <File>...</File> },
+ *   Schema({ node, options }) { return <File>...</File> },
+ * })
+ *
+ * @example
+ * // core generator
+ * export const myGenerator = defineGenerator<MyPlugin>({
+ *   name: 'my-generator',
+ *   type: 'core',
+ *   async operation({ node, options }) { return [{ path: '...', content: '...' }] },
+ * })
+ */
+declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserReactGeneratorV2<TPlugin>): ReactGeneratorV2<TPlugin>;
+declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserCoreGeneratorV2<TPlugin>): CoreGeneratorV2<TPlugin>;
 //#endregion
 //#region src/Kubb.d.ts
-type DebugEvent = {
+type DebugInfo = {
   date: Date;
-  logs: string[];
+  logs: Array<string>;
   fileName?: string;
 };
-type ProgressStartMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+type HookProgress<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   hookName: H;
   plugins: Array<Plugin>;
 };
-type ProgressStopMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  hookName: H;
-};
-type ExecutingMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+type HookExecution<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   strategy: Strategy;
   hookName: H;
   plugin: Plugin;
-  parameters?: unknown[] | undefined;
+  parameters?: Array<unknown>;
   output?: unknown;
 };
-type ExecutedMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   duration: number;
   strategy: Strategy;
   hookName: H;
   plugin: Plugin;
-  parameters?: unknown[] | undefined;
+  parameters?: Array<unknown>;
   output?: unknown;
 };
 /**
@@ -347,7 +330,7 @@ type ExecutedMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
  *
  * @example
  * ```typescript
- * import type { AsyncEventEmitter } from '@kubb/core'
+ * import type { AsyncEventEmitter } from '@internals/utils'
  * import type { KubbEvents } from '@kubb/core'
  *
  * const events: AsyncEventEmitter<KubbEvents> = new AsyncEventEmitter()
@@ -385,12 +368,12 @@ interface KubbEvents {
   /**
    * Emitted when code generation phase completes.
    */
-  'generation:end': [Config: Config, files: Array<KubbFile.ResolvedFile>, sources: Map<KubbFile.Path, string>];
+  'generation:end': [config: Config, files: Array<KubbFile.ResolvedFile>, sources: Map<KubbFile.Path, string>];
   /**
    * Emitted with a summary of the generation results.
    * Contains summary lines, title, and success status.
    */
-  'generation:summary': [Config: Config, {
+  'generation:summary': [config: Config, {
     failedPlugins: Set<{
       plugin: Plugin;
       error: Error;
@@ -398,7 +381,7 @@ interface KubbEvents {
     status: 'success' | 'failed';
     hrStart: [number, number];
     filesCreated: number;
-    pluginTimings?: Map<string, number>;
+    pluginTimings?: Map<Plugin['name'], number>;
   }];
   /**
    * Emitted when code formatting starts (e.g., running Biome or Prettier).
@@ -425,7 +408,7 @@ interface KubbEvents {
    */
   'hooks:end': [];
   /**
-   * Emitted when a single hook execution starts. (e.g., format or lint).
+   * Emitted when a single hook execution starts (e.g., format or lint).
    * The callback should be invoked when the command completes.
    */
   'hook:start': [{
@@ -467,7 +450,7 @@ interface KubbEvents {
    * Debug event for detailed logging.
    * Contains timestamp, log messages, and optional filename.
    */
-  debug: [meta: DebugEvent];
+  debug: [info: DebugInfo];
   /**
    * Emitted when file processing starts.
    * Contains the list of files to be processed.
@@ -478,10 +461,25 @@ interface KubbEvents {
    * Contains processed count, total count, percentage, and file details.
    */
   'file:processing:update': [{
-    /** Number of files processed so far */processed: number; /** Total number of files to process */
-    total: number; /** Processing percentage (0-100) */
-    percentage: number; /** Optional source identifier */
-    source?: string; /** The file being processed */
+    /**
+     * Number of files processed so far.
+     */
+    processed: number;
+    /**
+     * Total number of files to process.
+     */
+    total: number;
+    /**
+     * Processing percentage (0–100).
+     */
+    percentage: number;
+    /**
+     * Optional source identifier.
+     */
+    source?: string;
+    /**
+     * The file being processed.
+     */
     file: KubbFile.ResolvedFile;
     /**
      * Kubb configuration (not present in Fabric).
@@ -493,16 +491,16 @@ interface KubbEvents {
    * Emitted when file processing completes.
    * Contains the list of processed files.
    */
-  'files:processing:end': [files: KubbFile.ResolvedFile[]];
+  'files:processing:end': [files: Array<KubbFile.ResolvedFile>];
   /**
    * Emitted when a plugin starts executing.
    */
   'plugin:start': [plugin: Plugin];
   /**
    * Emitted when a plugin completes execution.
-   * Duration in ms
+   * Duration in ms.
    */
-  'plugin:end': [plugin: Plugin, meta: {
+  'plugin:end': [plugin: Plugin, result: {
     duration: number;
     success: boolean;
     error?: Error;
@@ -511,22 +509,24 @@ interface KubbEvents {
    * Emitted when plugin hook progress tracking starts.
    * Contains the hook name and list of plugins to execute.
    */
-  'plugins:hook:progress:start': [meta: ProgressStartMeta];
+  'plugins:hook:progress:start': [progress: HookProgress];
   /**
    * Emitted when plugin hook progress tracking ends.
    * Contains the hook name that completed.
    */
-  'plugins:hook:progress:end': [meta: ProgressStopMeta];
+  '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': [meta: ExecutingMeta];
+  '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': [meta: ExecutedMeta];
+  'plugins:hook:processing:end': [result: HookResult];
 }
 //#endregion
 //#region src/types.d.ts
@@ -589,11 +589,13 @@ type AdapterSource = {
  * - `TName` — unique string identifier (e.g. `'oas'`, `'asyncapi'`)
  * - `TOptions` — raw user-facing options passed to the adapter factory
  * - `TResolvedOptions` — defaults applied; what the adapter stores as `options`
+ * - `TDocument` — type of the raw source document exposed by the adapter after `parse()`
  */
-type AdapterFactoryOptions<TName extends string = string, TOptions extends object = object, TResolvedOptions extends object = TOptions> = {
+type AdapterFactoryOptions<TName extends string = string, TOptions extends object = object, TResolvedOptions extends object = TOptions, TDocument = unknown> = {
   name: TName;
   options: TOptions;
   resolvedOptions: TResolvedOptions;
+  document: TDocument;
 };
 /**
  * An adapter converts a source file or data into a `@kubb/ast` `RootNode`.
@@ -614,9 +616,35 @@ type AdapterFactoryOptions<TName extends string = string, TOptions extends objec
  * ```
  */
 type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
-  /** Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`. */name: TOptions['name']; /** Resolved options (after defaults have been applied). */
-  options: TOptions['resolvedOptions']; /** Convert the raw source into a universal `RootNode`. */
+  /**
+   * Human-readable identifier, e.g. `'oas'`, `'drizzle'`, `'asyncapi'`.
+   */
+  name: TOptions['name'];
+  /**
+   * Resolved options (after defaults have been applied).
+   */
+  options: TOptions['resolvedOptions'];
+  /**
+   * The raw source document produced after the first `parse()` call.
+   * `undefined` before parsing; typed by the adapter's `TDocument` generic.
+   */
+  document: TOptions['document'] | null;
+  rootNode: RootNode | null;
+  /**
+   * Convert the raw source into a universal `RootNode`.
+   */
   parse: (source: AdapterSource) => PossiblePromise<RootNode>;
+  /**
+   * Extracts `KubbFile.Import` entries needed by a `SchemaNode` tree.
+   * Populated after the first `parse()` call. Returns an empty array before that.
+   *
+   * The `resolve` callback receives the collision-corrected schema name and must
+   * return the `{ name, path }` pair for the import, or `undefined` to skip it.
+   */
+  getImports: (node: SchemaNode, resolve: (schemaName: string) => {
+    name: string;
+    path: string;
+  }) => Array<KubbFile.Import>;
 };
 type BarrelType = 'all' | 'named' | 'propagate';
 type DevtoolsOptions = {
@@ -681,16 +709,16 @@ type Config<TInput = Input> = {
     /**
      * Storage backend for generated files.
      * Defaults to `fsStorage()` — the built-in filesystem driver.
-     * Accepts any object implementing the {@link DefineStorage} interface.
+     * Accepts any object implementing the {@link Storage} interface.
      * Keys are root-relative paths (e.g. `src/gen/api/getPets.ts`).
      * @default fsStorage()
      * @example
      * ```ts
-     * import { defineStorage, fsStorage } from '@kubb/core'
-     * storage: defineStorage(fsStorage())
+     * import { memoryStorage } from '@kubb/core'
+     * storage: memoryStorage()
      * ```
      */
-    storage?: DefineStorage;
+    storage?: Storage;
     /**
      * Specifies the formatting tool to be used.
      * - 'auto' automatically detects and uses biome or prettier (in that order of preference).
@@ -720,7 +748,7 @@ type Config<TInput = Input> = {
      * Configures how `index.ts` files are created, including disabling barrel file generation. Each plugin has its own `barrelType` option; this setting controls the root barrel file (e.g., `src/gen/index.ts`).
      * @default 'named'
      */
-    barrelType?: Exclude<BarrelType, 'propagate'> | false;
+    barrelType?: 'all' | 'named' | false;
     /**
      * Adds a default banner to the start of every generated file indicating it was generated by Kubb.
      * - 'simple' adds banner with link to Kubb.
@@ -764,6 +792,67 @@ type Config<TInput = Input> = {
     done?: string | Array<string>;
   };
 };
+type PatternFilter = {
+  type: string;
+  pattern: string | RegExp;
+};
+type PatternOverride<TOptions> = PatternFilter & {
+  options: Omit<Partial<TOptions>, 'override'>;
+};
+type ResolveOptionsContext<TOptions> = {
+  options: TOptions;
+  exclude?: Array<PatternFilter>;
+  include?: Array<PatternFilter>;
+  override?: Array<PatternOverride<TOptions>>;
+};
+/**
+ * Base constraint for all plugin resolver objects.
+ *
+ * `default`, `resolveOptions`, `resolvePath`, and `resolveFile` are injected automatically
+ * by `defineResolver` — plugin authors may override them but never need to implement them
+ * from scratch.
+ *
+ * @example
+ * ```ts
+ * type MyResolver = Resolver & {
+ *   resolveName(node: SchemaNode): string
+ *   resolveTypedName(node: SchemaNode): string
+ * }
+ * ```
+ */
+type Resolver = {
+  name: string;
+  pluginName: Plugin['name'];
+  default(name: ResolveNameParams['name'], type?: ResolveNameParams['type']): string;
+  resolveOptions<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null;
+  resolvePath(params: ResolverPathParams, context: ResolverContext): KubbFile.Path;
+  resolveFile(params: ResolverFileParams, context: ResolverContext): KubbFile.File;
+  resolveBanner(node: RootNode | null, context: ResolveBannerContext): string | undefined;
+  resolveFooter(node: RootNode | 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'>;
+/**
+ * Base type for plugin builder objects.
+ * Concrete plugin builder types extend this with their own schema-building helpers.
+ * Use `defineBuilder` to define a builder object and export it alongside the plugin.
+ */
+type Builder = {
+  name: string;
+};
 type PluginFactoryOptions<
 /**
  * Name to be used for the plugin.
@@ -784,14 +873,25 @@ TContext = unknown,
 /**
  * When calling `resolvePath` you can specify better types.
  */
-TResolvePathOptions extends object = object> = {
+TResolvePathOptions extends object = object,
+/**
+ * Resolver object that encapsulates the naming and path-resolution helpers used by this plugin.
+ * Use `defineResolver` to define the resolver object and export it alongside the plugin.
+ */
+TResolver extends Resolver = Resolver,
+/**
+ * Builder object that encapsulates the schema-building helpers used by this plugin.
+ * Use `defineBuilder` to define the builder object and export it alongside the plugin.
+ */
+TBuilder extends Builder = Builder> = {
   name: TName;
   options: TOptions;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
+  resolver: TResolver;
+  builder: TBuilder;
 };
-type GetPluginFactoryOptions<TPlugin extends UserPlugin> = TPlugin extends UserPlugin<infer X> ? X : never;
 type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
@@ -815,7 +915,7 @@ type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
   inject?: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context'];
 };
 type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
-type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<any, any, any, any, any>>;
+type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<string, object, object, unknown, object>>;
 type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
@@ -837,7 +937,7 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   options: TOptions['resolvedOptions'];
   install: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
-   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `definePlugin`).
+   * Defines a context that can be used by other plugins, see `PluginDriver` where we convert from `UserPlugin` to `Plugin` (used when calling `createPlugin`).
    */
   inject: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context'];
 };
@@ -853,6 +953,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    * Options can als be included.
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
+   * @deprecated this will be replaced by resolvers
    */
   resolvePath?: (this: PluginContext<TOptions>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.Path;
   /**
@@ -860,6 +961,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    * Useful when converting to PascalCase or camelCase.
    * @type hookFirst
    * @example ('pet') => 'Pet'
+   * @deprecated this will be replaced by resolvers
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
 };
@@ -890,7 +992,7 @@ type ResolveNameParams = {
 type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   fabric: Fabric;
   config: Config;
-  pluginManager: PluginManager;
+  driver: PluginDriver;
   /**
    * Only add when the file does not exist yet
    */
@@ -905,22 +1007,30 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * Current plugin
    */
   plugin: Plugin<TOptions>;
-  /**
-   * Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
-   * Returns `undefined` when no adapter was set (legacy OAS-only usage).
-   */
-  rootNode: RootNode | undefined;
   /**
    * Opens the Kubb Studio URL for the current `rootNode` in the default browser.
    * Falls back to printing the URL if the browser cannot be launched.
    * No-ops silently when no adapter has set a `rootNode`.
    */
   openInStudio: (options?: DevtoolsOptions) => Promise<void>;
-} & Kubb.PluginContext;
+} & ({
+  /**
+   * Returns the universal `@kubb/ast` `RootNode` produced by the configured adapter.
+   * Returns `undefined` when no adapter was set (legacy OAS-only usage).
+   */
+  rootNode: RootNode;
+  /**
+   * Return the adapter from `@kubb/ast`
+   */
+  adapter: Adapter;
+} | {
+  rootNode?: never;
+  adapter?: never;
+}) & Kubb.PluginContext;
 /**
  * Specify the export location for the files and define the behavior of the output
  */
-type Output<TOptions> = {
+type Output<_TOptions = unknown> = {
   /**
    * Path to the output folder or file that will contain the generated code
    */
@@ -933,20 +1043,17 @@ type Output<TOptions> = {
   /**
    * Add a banner text in the beginning of every file
    */
-  banner?: string | ((options: TOptions) => string);
+  banner?: string | ((node: RootNode) => string);
   /**
    * Add a footer text in the beginning of every file
    */
-  footer?: string | ((options: TOptions) => string);
+  footer?: string | ((node: RootNode) => string);
   /**
    * Whether to override existing external files if they already exist.
    * @default false
    */
   override?: boolean;
 };
-type GroupContext = {
-  group: string;
-};
 type Group = {
   /**
    * Defines the type where to group the files.
@@ -956,9 +1063,11 @@ type Group = {
    */
   type: 'tag' | 'path';
   /**
-   * Return the name of a group based on the group name, this used for the file and name generation
+   * Return the name of a group based on the group name, this is used for the file and name generation.
    */
-  name?: (context: GroupContext) => string;
+  name?: (context: {
+    group: string;
+  }) => string;
 };
 type LoggerOptions = {
   /**
@@ -969,13 +1078,293 @@ type LoggerOptions = {
 /**
  * Shared context passed to all plugins, parsers, and Fabric internals.
  */
-interface LoggerContext extends AsyncEventEmitter<KubbEvents> {}
-type Install<TOptions = unknown> = (context: LoggerContext, options?: TOptions) => void | Promise<void>;
+type LoggerContext = AsyncEventEmitter<KubbEvents>;
 type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
   name: string;
-  install: Install<TOptions>;
+  install: (context: LoggerContext, options?: TOptions) => void | Promise<void>;
+};
+type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOptions>;
+/**
+ * Compatibility preset for code generation tools.
+ * - `'default'` – no compatibility adjustments (default behavior).
+ * - `'kubbV4'` – align generated names and structures with Kubb v4 output.
+ */
+type CompatibilityPreset = 'default' | 'kubbV4';
+/**
+ * A preset bundles a name, one or more resolvers, optional AST transformers,
+ * and optional generators into a single reusable configuration object.
+ *
+ * @template TResolver - The concrete resolver type for this preset.
+ */
+type Preset<TResolver extends Resolver = Resolver> = {
+  /**
+   * Unique identifier for this preset.
+   */
+  name: string;
+  /**
+   * Ordered list of resolvers applied by this preset (last entry wins on merge).
+   */
+  resolvers: Array<TResolver>;
+  /**
+   * Optional AST visitors / transformers applied after resolving.
+   */
+  transformers?: Array<Visitor>;
+  /**
+   * Optional generators used by this preset. Plugin implementations cast this
+   * to their concrete generator type.
+   */
+  generators?: Array<Generator<any>>;
+};
+/**
+ * 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.
+ */
+type Presets<TResolver extends Resolver = Resolver> = Record<CompatibilityPreset, Preset<TResolver>>;
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+type ResolvePathOptions = {
+  pluginName?: string;
+  group?: {
+    tag?: string;
+    path?: string;
+  };
+  type?: ResolveNameParams['type'];
+};
+/**
+ * File-specific parameters for `Resolver.resolvePath`.
+ *
+ * Pass alongside a `ResolverContext` to identify which file to resolve.
+ * Provide `tag` for tag-based grouping or `path` for path-based grouping.
+ *
+ * @example
+ * ```ts
+ * resolver.resolvePath(
+ *   { baseName: 'petTypes.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → '/src/types/petsController/petTypes.ts'
+ * ```
+ */
+type ResolverPathParams = {
+  baseName: KubbFile.BaseName;
+  pathMode?: KubbFile.Mode;
+  /**
+   * Tag value used when `group.type === 'tag'`.
+   */
+  tag?: string;
+  /**
+   * Path value used when `group.type === 'path'`.
+   */
+  path?: string;
+};
+/**
+ * Shared context passed as the second argument to `Resolver.resolvePath` and `Resolver.resolveFile`.
+ *
+ * Describes where on disk output is rooted, which output config is active, and the optional
+ * grouping strategy that controls subdirectory layout.
+ *
+ * @example
+ * ```ts
+ * const context: ResolverContext = {
+ *   root: config.root,
+ *   output,
+ *   group,
+ * }
+ * ```
+ */
+type ResolverContext = {
+  root: string;
+  output: Output;
+  group?: Group; /** Plugin name used to populate `meta.pluginName` on the resolved file. */
+  pluginName?: string;
+};
+/**
+ * File-specific parameters for `Resolver.resolveFile`.
+ *
+ * Pass alongside a `ResolverContext` to fully describe the file to resolve.
+ * `tag` and `path` are used only when a matching `group` is present in the context.
+ *
+ * @example
+ * ```ts
+ * resolver.resolveFile(
+ *   { name: 'listPets', extname: '.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+ * ```
+ */
+type ResolverFileParams = {
+  name: string;
+  extname: KubbFile.Extname; /** Tag value used when `group.type === 'tag'`. */
+  tag?: string; /** Path value used when `group.type === 'path'`. */
+  path?: string;
+};
+/**
+ * Context passed to `Resolver.resolveBanner` and `Resolver.resolveFooter`.
+ *
+ * `output` is optional — not every plugin configures a banner/footer.
+ * `config` carries the global Kubb config, used to derive the default Kubb banner.
+ *
+ * @example
+ * ```ts
+ * resolver.resolveBanner(rootNode, { output: { banner: '// generated' }, config })
+ * // → '// generated'
+ * ```
+ */
+type ResolveBannerContext = {
+  output?: Pick<Output, 'banner' | 'footer'>;
+  config: Config;
+};
+//#endregion
+//#region src/PluginDriver.d.ts
+type RequiredPluginLifecycle = Required<PluginLifecycle>;
+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 = {
+  fabric: Fabric;
+  events: AsyncEventEmitter<KubbEvents>;
+  /**
+   * @default Number.POSITIVE_INFINITY
+   */
+  concurrency?: number;
+};
+type GetFileOptions<TOptions = object> = {
+  name: string;
+  mode?: KubbFile.Mode;
+  extname: KubbFile.Extname;
+  pluginName: string;
+  options?: TOptions;
 };
-type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Omit<Logger<TOptions>, 'logLevel'>;
+declare function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode;
+declare class PluginDriver {
+  #private;
+  readonly config: Config;
+  readonly options: Options;
+  /**
+   * The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+   * the build pipeline after the adapter's `parse()` resolves.
+   */
+  rootNode: RootNode | undefined;
+  adapter: Adapter | undefined;
+  constructor(config: Config, options: Options);
+  get events(): AsyncEventEmitter<KubbEvents>;
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
+  get plugins(): Array<Plugin>;
+  getFile<TOptions = object>({
+    name,
+    mode,
+    extname,
+    pluginName,
+    options
+  }: GetFileOptions<TOptions>): KubbFile.File<{
+    pluginName: string;
+  }>;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
+  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 `pre`/`post` settings.
+   */
+  hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+  }): Promise<Awaited<TOutput>[]>;
+  /**
+   * Chains plugins
+   */
+  hookSeq<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: PluginParameter<H>;
+  }): Promise<void>;
+  getPluginByName(pluginName: string): Plugin | undefined;
+  getPluginsByName(hookName: keyof PluginWithLifeCycle, pluginName: string): Plugin[];
+}
 //#endregion
-export { UserPluginWithLifeCycle as A, URLPath as B, PrinterFactoryOptions as C, UserConfig as D, UnknownUserPlugin as E, defineStorage as F, formatters as I, linters as L, PluginManager as M, getMode as N, UserLogger as O, DefineStorage as P, logLevel as R, Printer as S, ResolvePathParams as T, PluginFactoryOptions as _, Config as a, PluginParameter as b, Group as c, Logger as d, LoggerContext as f, PluginContext as g, Plugin as h, BarrelType as i, KubbEvents as j, UserPlugin as k, InputData as l, Output as m, AdapterFactoryOptions as n, DevtoolsOptions as o, LoggerOptions as p, AdapterSource as r, GetPluginFactoryOptions as s, Adapter as t, InputPath as u, PluginLifecycle as v, ResolveNameParams as w, PluginWithLifeCycle as x, PluginLifecycleHooks as y, AsyncEventEmitter as z };
-//# sourceMappingURL=types-B7eZvqwD.d.ts.map
+export { formatters as $, Printer as A, ResolverPathParams as B, PluginFactoryOptions as C, PluginWithLifeCycle as D, PluginParameter as E, ResolvePathOptions as F, UserResolver as G, UserLogger as H, ResolvePathParams as I, Generator as J, KubbEvents as K, Resolver as L, ResolveBannerContext as M, ResolveNameParams as N, Preset as O, ResolveOptionsContext as P, createStorage as Q, ResolverContext as R, PluginContext as S, PluginLifecycleHooks as T, UserPlugin as U, UserConfig as V, UserPluginWithLifeCycle as W, defineGenerator as X, ReactGeneratorV2 as Y, Storage as Z, LoggerContext as _, AdapterSource as a, Override as b, CompatibilityPreset as c, Exclude as d, linters as et, Group as f, Logger as g, InputPath as h, AdapterFactoryOptions as i, PrinterFactoryOptions as j, Presets as k, Config as l, InputData as m, getMode as n, PossiblePromise as nt, BarrelType as o, Include as p, CoreGeneratorV2 as q, Adapter as r, AsyncEventEmitter as rt, Builder as s, PluginDriver as t, logLevel as tt, DevtoolsOptions as u, LoggerOptions as v, PluginLifecycle as w, Plugin as x, Output as y, ResolverFileParams as z };
+//# sourceMappingURL=PluginDriver-CEQPafXV.d.ts.map