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

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

@@ -1,100 +1,101 @@
 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 { FabricReactNode } from "@kubb/react-fabric/types";
 
-//#region ../../internals/utils/dist/index.d.ts
+//#region ../../internals/utils/src/asyncEventEmitter.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;
-  };
-};
-/**
-* 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 +104,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 +128,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 +153,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 +200,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;
-  pluginName: string;
-  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,
-    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[];
-}
+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 +241,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 +279,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 +292,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 +319,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 +361,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 +372,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 +402,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 +420,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 {
@@ -589,11 +585,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 +612,34 @@ 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'];
+  /**
+   * 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 +704,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,6 +787,40 @@ 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 = {
+  name: string;
+  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.
@@ -784,14 +841,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;
   options: TOptions;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
+  resolver: TResolver;
 };
-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 +877,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 +899,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'];
 };
@@ -890,7 +952,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,18 +967,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
  */
@@ -944,9 +1014,6 @@ type Output<TOptions> = {
    */
   override?: boolean;
 };
-type GroupContext = {
-  group: string;
-};
 type Group = {
   /**
    * Defines the type where to group the files.
@@ -956,9 +1023,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 +1038,166 @@ 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> = Omit<Logger<TOptions>, 'logLevel'>;
+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, and optional AST transformers
+ * 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>;
+};
+/**
+ * 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>>;
+//#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;
+};
+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 { ResolveOptionsContext as A, ReactGeneratorV2 as B, PluginParameter as C, Printer as D, Presets as E, UserPlugin as F, formatters as G, KubbEvents as H, UserPluginWithLifeCycle as I, PossiblePromise as J, linters as K, UserResolver as L, Resolver as M, UserConfig as N, PrinterFactoryOptions as O, UserLogger as P, CoreGeneratorV2 as R, PluginLifecycleHooks as S, Preset as T, Storage as U, defineGenerator as V, createStorage as W, AsyncEventEmitter as Y, Output as _, AdapterFactoryOptions as a, PluginFactoryOptions as b, CompatibilityPreset as c, Group as d, InputData as f, LoggerOptions as g, LoggerContext as h, Adapter as i, ResolvePathParams as j, ResolveNameParams as k, Config as l, Logger as m, PluginDriver as n, AdapterSource as o, InputPath as p, logLevel as q, getMode as r, BarrelType as s, GetFileOptions as t, DevtoolsOptions as u, Plugin as v, PluginWithLifeCycle as w, PluginLifecycle as x, PluginContext as y, Generator as z };
+//# sourceMappingURL=PluginDriver-BkSenc-R.d.ts.map