@kubb/core 5.0.0-alpha.1 → 5.0.0-alpha.11

package/dist/{types-D30QAz2y.d.ts → PluginDriver-BkFepPdm.d.ts}

@@ -1,8 +1,8 @@
 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 } from "@kubb/ast/types";
+import { Fabric, KubbFile } from "@kubb/fabric-core/types";
+import { FabricReactNode } from "@kubb/react-fabric/types";
 
 //#region ../../internals/utils/dist/index.d.ts
 /**
@@ -23,75 +23,6 @@ declare var AsyncEventEmitter: {
     removeAll(): void;
   };
 };
-/**
-* 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;
-  };
-};
-/**
-* 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;
 //#endregion
 //#region src/constants.d.ts
 declare const DEFAULT_STUDIO_URL: "https://studio.kubb.dev";
@@ -138,46 +69,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 +116,39 @@ 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;
-//#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;
-};
-type Options = {
-  fabric: Fabric;
-  events: AsyncEventEmitter<KubbEvents>;
-  /**
-   * @default Number.POSITIVE_INFINITY
-   */
-  concurrency?: number;
-};
-type GetFileProps<TOptions = object> = {
-  name: string;
-  mode?: KubbFile.Mode;
-  extname: KubbFile.Extname;
-  pluginKey: Plugin['key'];
-  options?: TOptions;
-};
-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,
-    pluginKey,
-    options
-  }: GetFileProps<TOptions>): KubbFile.File<{
-    pluginKey: Plugin['key'];
-  }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
-  resolveName: (params: ResolveNameParams) => string;
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPlugin<H extends PluginLifecycleHooks>({
-    pluginKey,
-    hookName,
-    parameters
-  }: {
-    pluginKey: Plugin['key'];
-    hookName: H;
-    parameters: PluginParameter<H>;
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
-  /**
-   * Run a specific hookName for plugin x.
-   */
-  hookForPluginSync<H extends PluginLifecycleHooks>({
-    pluginKey,
-    hookName,
-    parameters
-  }: {
-    pluginKey: Plugin['key'];
-    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>;
-  getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined;
-  getPluginsByKey(hookName: keyof PluginWithLifeCycle, pluginKey: Plugin['key']): Plugin[];
-}
+declare function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage;
 //#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 +157,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 +195,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 +208,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 +235,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 +277,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 +288,10 @@ 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 +303,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,24 +321,111 @@ 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/defineGenerator.d.ts
+/**
+ * Props for the `operations` lifecycle — receives all operation nodes at once.
+ */
+type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  options: Plugin<TPlugin>['options'];
+  nodes: Array<OperationNode>;
+};
+/**
+ * Props for the `operation` lifecycle — receives a single operation node.
+ */
+type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  options: Plugin<TPlugin>['options'];
+  node: OperationNode;
+};
+/**
+ * Props for the `schema` lifecycle — receives a single schema node.
+ */
+type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  options: Plugin<TPlugin>['options'];
+  node: SchemaNode;
+};
+type UserCoreGeneratorV2<TPlugin extends 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 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/types.d.ts
 declare global {
   namespace Kubb {
@@ -617,6 +514,17 @@ 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`. */
   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 +589,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).
@@ -764,9 +672,42 @@ 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` and `resolveOptions` are injected automatically by `defineResolver` — plugin
+ * authors may override them but never need to implement them from scratch.
+ * Concrete plugin resolver types extend this with their own helper methods.
+ */
+type Resolver = {
+  default(name: ResolveNameParams['name'], type?: ResolveNameParams['type']): string;
+  resolveOptions<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null;
+};
+/**
+ * The user-facing subset of a `Resolver` — everything except the methods injected by
+ * `defineResolver` (`default` and `resolveOptions`).
+ *
+ * When you pass a `UserResolver` to `defineResolver`, the standard `default` and
+ * `resolveOptions` implementations are injected automatically so plugin authors never
+ * need to define them by hand. Both can still be overridden by providing them explicitly.
+ */
+type UserResolver = Omit<Resolver, 'default' | 'resolveOptions'>;
 type PluginFactoryOptions<
 /**
- * Name to be used for the plugin, this will also be used for they key.
+ * Name to be used for the plugin.
  */
 TName extends string = string,
 /**
@@ -784,19 +725,19 @@ 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> = {
   name: TName;
-  /**
-   * Same behavior like what has been done with `QueryKey` in `@tanstack/react-query`
-   */
-  key: PluginKey<TName | string>;
   options: TOptions;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
+  resolver: TResolver;
 };
-type PluginKey<TName> = [name: TName, identifier?: string | number];
-type GetPluginFactoryOptions<TPlugin extends UserPlugin> = TPlugin extends UserPlugin<infer X> ? X : never;
 type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
@@ -820,18 +761,13 @@ 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
    * @example @kubb/typescript
    */
   name: TOptions['name'];
-  /**
-   * Internal key used when a developer uses more than one of the same plugin
-   * @private
-   */
-  key: TOptions['key'];
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -847,7 +783,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'];
 };
@@ -876,7 +812,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
 type ResolvePathParams<TOptions = object> = {
-  pluginKey?: Plugin['key'];
+  pluginName?: string;
   baseName: KubbFile.BaseName;
   mode?: KubbFile.Mode;
   /**
@@ -886,7 +822,7 @@ type ResolvePathParams<TOptions = object> = {
 };
 type ResolveNameParams = {
   name: string;
-  pluginKey?: Plugin['key'];
+  pluginName?: string;
   /**
    * Specifies the type of entity being named.
    * - 'file' customizes the name of the created file (uses camelCase).
@@ -900,7 +836,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
    */
@@ -915,18 +851,26 @@ 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
  */
@@ -954,9 +898,6 @@ type Output<TOptions> = {
    */
   override?: boolean;
 };
-type GroupContext = {
-  group: string;
-};
 type Group = {
   /**
    * Defines the type where to group the files.
@@ -966,9 +907,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 = {
   /**
@@ -979,13 +922,133 @@ 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>;
+//#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 { UserPlugin as A, AsyncEventEmitter as B, Printer as C, UnknownUserPlugin as D, ResolvePathParams as E, DefineStorage as F, defineStorage as I, formatters as L, KubbEvents as M, PluginManager as N, UserConfig as O, getMode as P, linters as R, PluginWithLifeCycle as S, ResolveNameParams as T, URLPath as V, PluginFactoryOptions as _, Config as a, PluginLifecycleHooks as b, Group as c, Logger as d, LoggerContext as f, PluginContext as g, Plugin as h, BarrelType as i, UserPluginWithLifeCycle as j, UserLogger 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, PluginKey as v, PrinterFactoryOptions as w, PluginParameter as x, PluginLifecycle as y, logLevel as z };
-//# sourceMappingURL=types-D30QAz2y.d.ts.map
+export { UserConfig as A, Storage as B, PluginWithLifeCycle as C, ResolveOptionsContext as D, ResolveNameParams as E, CoreGeneratorV2 as F, AsyncEventEmitter as G, formatters as H, Generator as I, ReactGeneratorV2 as L, UserPlugin as M, UserPluginWithLifeCycle as N, ResolvePathParams as O, UserResolver as P, defineGenerator as R, PluginParameter as S, PrinterFactoryOptions as T, linters as U, createStorage as V, logLevel as W, Plugin as _, AdapterFactoryOptions as a, PluginLifecycle as b, Config as c, InputData as d, InputPath as f, Output as g, LoggerOptions as h, Adapter as i, UserLogger as j, Resolver as k, DevtoolsOptions as l, LoggerContext as m, PluginDriver as n, AdapterSource as o, Logger as p, getMode as r, BarrelType as s, GetFileOptions as t, Group as u, PluginContext as v, Printer as w, PluginLifecycleHooks as x, PluginFactoryOptions as y, KubbEvents as z };
+//# sourceMappingURL=PluginDriver-BkFepPdm.d.ts.map