@kubb/core 5.0.0-alpha.3 → 5.0.0-alpha.30

package/dist/PluginDriver-D110FoJ-.d.ts

@@ -0,0 +1,1632 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { Node, OperationNode, Printer, Printer as Printer$1, PrinterFactoryOptions, PrinterPartial, RootNode, SchemaNode, Visitor } from "@kubb/ast/types";
+import { Fabric, FabricFile } from "@kubb/fabric-core/types";
+import { HttpMethod } from "@kubb/oas";
+import { FabricReactNode } from "@kubb/react-fabric/types";
+
+//#region ../../internals/utils/src/asyncEventEmitter.d.ts
+/**
+ * A function that can be registered as an event listener, synchronous or async.
+ */
+type AsyncListener<TArgs extends unknown[]> = (...args: TArgs) => void | Promise<void>;
+/**
+ * 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 sequentially.
+   * 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;
+  readonly warn: 1;
+  readonly info: 3;
+  readonly verbose: 4;
+  readonly debug: 5;
+};
+/**
+ * CLI command descriptors for each supported linter.
+ *
+ * Each entry contains the executable `command`, an `args` factory that maps an
+ * output path to the correct argument list, and an `errorMessage` shown when
+ * the linter is not found.
+ */
+declare const linters: {
+  readonly eslint: {
+    readonly command: "eslint";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Eslint not found";
+  };
+  readonly biome: {
+    readonly command: "biome";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Biome not found";
+  };
+  readonly oxlint: {
+    readonly command: "oxlint";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Oxlint not found";
+  };
+};
+/**
+ * CLI command descriptors for each supported code formatter.
+ *
+ * Each entry contains the executable `command`, an `args` factory that maps an
+ * output path to the correct argument list, and an `errorMessage` shown when
+ * the formatter is not found.
+ */
+declare const formatters: {
+  readonly prettier: {
+    readonly command: "prettier";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Prettier not found";
+  };
+  readonly biome: {
+    readonly command: "biome";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Biome not found";
+  };
+  readonly oxfmt: {
+    readonly command: "oxfmt";
+    readonly args: (outputPath: string) => string[];
+    readonly errorMessage: "Oxfmt not found";
+  };
+};
+//#endregion
+//#region src/createStorage.d.ts
+type Storage = {
+  /**
+   * Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`).
+   */
+  readonly name: string;
+  /**
+   * 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.
+   */
+  getItem(key: string): Promise<string | null>;
+  /**
+   * 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.
+   */
+  removeItem(key: string): Promise<void>;
+  /**
+   * 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`.
+   */
+  clear(base?: string): Promise<void>;
+  /**
+   * Optional teardown hook called after the build completes.
+   */
+  dispose?(): Promise<void>;
+};
+/**
+ * Creates a storage factory. Call the returned function with optional options to get the storage instance.
+ *
+ * @example
+ * export const memoryStorage = createStorage(() => {
+ *   const store = new Map<string, string>()
+ *   return {
+ *     name: 'memory',
+ *     async hasItem(key) { return store.has(key) },
+ *     async getItem(key) { return store.get(key) ?? null },
+ *     async setItem(key, value) { store.set(key, value) },
+ *     async removeItem(key) { store.delete(key) },
+ *     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 createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage;
+//#endregion
+//#region src/defineGenerator.d.ts
+/**
+ * A generator is a named object with optional `schema`, `operation`, and `operations`
+ * methods. Each method is called with `this = PluginContext` of the parent plugin,
+ * giving full access to `this.config`, `this.resolver`, `this.adapter`, `this.fabric`,
+ * `this.driver`, etc.
+ *
+ * Return a React element, an array of `FabricFile.File`, or `void` to handle file
+ * writing manually via `this.upsertFile`. Both React and core (non-React) generators
+ * use the same method signatures — the return type determines how output is handled.
+ *
+ * @example
+ * ```ts
+ * export const typeGenerator = defineGenerator<PluginTs>({
+ *   name: 'typescript',
+ *   schema(node, options) {
+ *     const { adapter, resolver, root } = this
+ *     return <File ...><Type node={node} resolver={resolver} /></File>
+ *   },
+ *   operation(node, options) {
+ *     return <File ...><OperationType node={node} /></File>
+ *   },
+ * })
+ * ```
+ */
+type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /** Used in diagnostic messages and debug output. */name: string;
+  /**
+   * Called for each schema node in the AST walk.
+   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   * `options` contains the per-node resolved options (after exclude/include/override).
+   */
+  schema?: (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+  /**
+   * Called for each operation node in the AST walk.
+   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   */
+  operation?: (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+  /**
+   * Called once after all operations have been walked.
+   * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
+   */
+  operations?: (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+};
+/**
+ * Defines a generator. Returns the object as-is with correct `this` typings.
+ * No type discrimination (`type: 'react' | 'core'`) needed — `applyHookResult`
+ * handles React elements and `File[]` uniformly.
+ */
+declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(generator: Generator<TOptions>): Generator<TOptions>;
+/**
+ * Merges an array of generators into a single generator.
+ *
+ * The merged generator's `schema`, `operation`, and `operations` methods run
+ * the corresponding method from each input generator in sequence, applying each
+ * result via `applyHookResult`. This eliminates the need to write the loop
+ * manually in each plugin.
+ *
+ * @param generators - Array of generators to merge into a single generator.
+ *
+ * @example
+ * ```ts
+ * const merged = mergeGenerators(generators)
+ *
+ * return {
+ *   name: pluginName,
+ *   schema: merged.schema,
+ *   operation: merged.operation,
+ *   operations: merged.operations,
+ * }
+ * ```
+ */
+declare function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(generators: Array<Generator<TOptions>>): Generator<TOptions>;
+//#endregion
+//#region src/Kubb.d.ts
+type DebugInfo = {
+  date: Date;
+  logs: Array<string>;
+  fileName?: string;
+};
+type HookProgress<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H;
+  plugins: Array<Plugin>;
+};
+type HookExecution<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: Array<unknown>;
+  output?: unknown;
+};
+type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  duration: number;
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: Array<unknown>;
+  output?: unknown;
+};
+/**
+ * Events emitted during the Kubb code generation lifecycle.
+ * These events can be listened to for logging, progress tracking, and custom integrations.
+ *
+ * @example
+ * ```typescript
+ * import type { AsyncEventEmitter } from '@internals/utils'
+ * import type { KubbEvents } from '@kubb/core'
+ *
+ * const events: AsyncEventEmitter<KubbEvents> = new AsyncEventEmitter()
+ *
+ * events.on('lifecycle:start', () => {
+ *   console.log('Starting Kubb generation')
+ * })
+ *
+ * events.on('plugin:end', (plugin, { duration }) => {
+ *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
+ * })
+ * ```
+ */
+interface KubbEvents {
+  /**
+   * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
+   */
+  'lifecycle:start': [version: string];
+  /**
+   * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
+   */
+  'lifecycle:end': [];
+  /**
+   * Emitted when configuration loading starts.
+   */
+  'config:start': [];
+  /**
+   * Emitted when configuration loading is complete.
+   */
+  'config:end': [configs: Array<Config>];
+  /**
+   * Emitted when code generation phase starts.
+   */
+  'generation:start': [config: Config];
+  /**
+   * Emitted when code generation phase completes.
+   */
+  'generation:end': [config: Config, files: Array<FabricFile.ResolvedFile>, sources: Map<FabricFile.Path, string>];
+  /**
+   * Emitted with a summary of the generation results.
+   * Contains summary lines, title, and success status.
+   */
+  'generation:summary': [config: Config, {
+    failedPlugins: Set<{
+      plugin: Plugin;
+      error: Error;
+    }>;
+    status: 'success' | 'failed';
+    hrStart: [number, number];
+    filesCreated: number;
+    pluginTimings?: Map<Plugin['name'], number>;
+  }];
+  /**
+   * Emitted when code formatting starts (e.g., running Biome or Prettier).
+   */
+  'format:start': [];
+  /**
+   * Emitted when code formatting completes.
+   */
+  'format:end': [];
+  /**
+   * Emitted when linting starts.
+   */
+  'lint:start': [];
+  /**
+   * Emitted when linting completes.
+   */
+  'lint:end': [];
+  /**
+   * Emitted when plugin hooks execution starts.
+   */
+  'hooks:start': [];
+  /**
+   * Emitted when plugin hooks execution completes.
+   */
+  'hooks:end': [];
+  /**
+   * Emitted when a single hook execution starts (e.g., format or lint).
+   * The callback should be invoked when the command completes.
+   */
+  'hook:start': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+  }];
+  /**
+   * Emitted when a single hook execution completes.
+   */
+  'hook:end': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+    success: boolean;
+    error: Error | null;
+  }];
+  /**
+   * Emitted when a new version of Kubb is available.
+   */
+  'version:new': [currentVersion: string, latestVersion: string];
+  /**
+   * Informational message event.
+   */
+  info: [message: string, info?: string];
+  /**
+   * Error event. Emitted when an error occurs during code generation.
+   */
+  error: [error: Error, meta?: Record<string, unknown>];
+  /**
+   * Success message event.
+   */
+  success: [message: string, info?: string];
+  /**
+   * Warning message event.
+   */
+  warn: [message: string, info?: string];
+  /**
+   * Debug event for detailed logging.
+   * Contains timestamp, log messages, and optional filename.
+   */
+  debug: [info: DebugInfo];
+  /**
+   * Emitted when file processing starts.
+   * Contains the list of files to be processed.
+   */
+  'files:processing:start': [files: Array<FabricFile.ResolvedFile>];
+  /**
+   * Emitted for each file being processed, providing progress updates.
+   * 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.
+     */
+    file: FabricFile.ResolvedFile;
+    /**
+     * Kubb configuration (not present in Fabric).
+     * Provides access to the current config during file processing.
+     */
+    config: Config;
+  }];
+  /**
+   * Emitted when file processing completes.
+   * Contains the list of processed files.
+   */
+  'files:processing:end': [files: Array<FabricFile.ResolvedFile>];
+  /**
+   * Emitted when a plugin starts executing.
+   */
+  'plugin:start': [plugin: Plugin];
+  /**
+   * Emitted when a plugin completes execution.
+   * Duration in ms.
+   */
+  'plugin:end': [plugin: Plugin, result: {
+    duration: number;
+    success: boolean;
+    error?: Error;
+  }];
+  /**
+   * Emitted when plugin hook progress tracking starts.
+   * Contains the hook name and list of plugins to execute.
+   */
+  'plugins:hook:progress:start': [progress: HookProgress];
+  /**
+   * Emitted when plugin hook progress tracking ends.
+   * Contains the hook name that completed.
+   */
+  'plugins:hook:progress:end': [{
+    hookName: PluginLifecycleHooks;
+  }];
+  /**
+   * Emitted when a plugin hook starts processing.
+   * Contains strategy, hook name, plugin, parameters, and output.
+   */
+  'plugins:hook:processing:start': [execution: HookExecution];
+  /**
+   * Emitted when a plugin hook completes processing.
+   * Contains duration, strategy, hook name, plugin, parameters, and output.
+   */
+  'plugins:hook:processing:end': [result: HookResult];
+}
+//#endregion
+//#region src/types.d.ts
+declare global {
+  namespace Kubb {
+    interface PluginContext {}
+    /**
+     * Registry that maps plugin names to their `PluginFactoryOptions`.
+     * Augment this interface in each plugin's `types.ts` to enable automatic
+     * typing for `getPlugin` and `requirePlugin`.
+     *
+     * @example
+     * ```ts
+     * // packages/plugin-ts/src/types.ts
+     * declare global {
+     *   namespace Kubb {
+     *     interface PluginRegistry {
+     *       'plugin-ts': PluginTs
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    interface PluginRegistry {}
+  }
+}
+/**
+ * Config used in `kubb.config.ts`
+ *
+ * @example
+ * import { defineConfig } from '@kubb/core'
+ * export default defineConfig({
+ * ...
+ * })
+ */
+type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins'> & {
+  /**
+   * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
+   * @default process.cwd()
+   */
+  root?: string;
+  /**
+   * An array of Kubb plugins used for generation. Each plugin may have additional configurable options (defined within the plugin itself). If a plugin relies on another plugin, an error will occur if the required dependency is missing. Refer to “pre” for more details.
+   */
+  plugins?: Array<Omit<UnknownUserPlugin, 'inject'>>;
+};
+type InputPath = {
+  /**
+   * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
+   */
+  path: string;
+};
+type InputData = {
+  /**
+   * A `string` or `object` that contains your Swagger/OpenAPI data.
+   */
+  data: string | unknown;
+};
+type Input = InputPath | InputData | Array<InputPath>;
+/**
+ * The raw source passed to an adapter's `parse` function.
+ * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
+ */
+type AdapterSource = {
+  type: 'path';
+  path: string;
+} | {
+  type: 'data';
+  data: string | unknown;
+} | {
+  type: 'paths';
+  paths: Array<string>;
+};
+/**
+ * Type parameters for an adapter definition.
+ *
+ * Mirrors `PluginFactoryOptions` but scoped to the adapter lifecycle:
+ * - `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, TDocument = unknown> = {
+  name: TName;
+  options: TOptions;
+  resolvedOptions: TResolvedOptions;
+  document: TDocument;
+};
+/**
+ * An adapter converts a source file or data into a `@kubb/ast` `RootNode`.
+ *
+ * Adapters are the single entry-point for different schema formats
+ * (OpenAPI, AsyncAPI, Drizzle, …) and produce the universal `RootNode`
+ * that all Kubb plugins consume.
+ *
+ * @example
+ * ```ts
+ * import { oasAdapter } from '@kubb/adapter-oas'
+ *
+ * export default defineConfig({
+ *   adapter: adapterOas(),         // default — OpenAPI / Swagger
+ *   input:   { path: './openapi.yaml' },
+ *   plugins: [pluginTs(), pluginZod()],
+ * })
+ * ```
+ */
+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'];
+  /**
+   * 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 `FabricFile.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<FabricFile.Import>;
+};
+type BarrelType = 'all' | 'named' | 'propagate';
+type DevtoolsOptions = {
+  /**
+   * Open the AST inspector view (`/ast`) in Kubb Studio.
+   * When `false`, opens the main Studio page instead.
+   * @default false
+   */
+  ast?: boolean;
+};
+/**
+ * @private
+ */
+type Config<TInput = Input> = {
+  /**
+   * The name to display in the CLI output.
+   */
+  name?: string;
+  /**
+   * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
+   * @default process.cwd()
+   */
+  root: string;
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `RootNode` — the universal
+   * intermediate representation consumed by all Kubb plugins.
+   *
+   * - Omit (or pass `undefined`) to use the built-in OpenAPI/Swagger adapter.
+   * - Use `@kubb/adapter-oas` for explicit OpenAPI configuration (validate, contentType, …).
+   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
+   *
+   * @example
+   * ```ts
+   * import { drizzleAdapter } from '@kubb/adapter-drizzle'
+   * export default defineConfig({
+   *   adapter: drizzleAdapter(),
+   *   input: { path: './src/schema.ts' },
+   * })
+   * ```
+   */
+  adapter?: Adapter;
+  /**
+   * You can use either `input.path` or `input.data`, depending on your specific needs.
+   */
+  input: TInput;
+  output: {
+    /**
+     * The path where all generated files receives exported.
+     * This can be an absolute path or a path relative to the specified root option.
+     */
+    path: string;
+    /**
+     * Clean the output directory before each build.
+     */
+    clean?: boolean;
+    /**
+     * Save files to the file system.
+     * @default true
+     * @deprecated Use `storage` to control where files are written.
+     */
+    write?: boolean;
+    /**
+     * Storage backend for generated files.
+     * Defaults to `fsStorage()` — the built-in filesystem driver.
+     * 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 { memoryStorage } from '@kubb/core'
+     * storage: memoryStorage()
+     * ```
+     */
+    storage?: Storage;
+    /**
+     * Specifies the formatting tool to be used.
+     * - 'auto' automatically detects and uses biome or prettier (in that order of preference).
+     * - 'prettier' uses Prettier for code formatting.
+     * - 'biome' uses Biome for code formatting.
+     * - 'oxfmt' uses Oxfmt for code formatting.
+     * - false disables code formatting.
+     * @default 'prettier'
+     */
+    format?: 'auto' | 'prettier' | 'biome' | 'oxfmt' | false;
+    /**
+     * Specifies the linter that should be used to analyze the code.
+     * - 'auto' automatically detects and uses biome, oxlint, or eslint (in that order of preference).
+     * - 'eslint' uses ESLint for linting.
+     * - 'biome' uses Biome for linting.
+     * - 'oxlint' uses Oxlint for linting.
+     * - false disables linting.
+     * @default 'auto'
+     */
+    lint?: 'auto' | 'eslint' | 'biome' | 'oxlint' | false;
+    /**
+     * Overrides the extension for generated imports and exports. By default, each plugin adds an extension.
+     * @default { '.ts': '.ts'}
+     */
+    extension?: Record<FabricFile.Extname, FabricFile.Extname | ''>;
+    /**
+     * 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?: '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.
+     * - 'full' adds source, title, description, and OpenAPI version.
+     * - false disables banner generation.
+     * @default 'simple'
+     */
+    defaultBanner?: 'simple' | 'full' | false;
+    /**
+     * Whether to override existing external files if they already exist.
+     * When setting the option in the global configuration, all plugins inherit the same behavior by default.
+     * However, all plugins also have an `output.override` option, which can be used to override the behavior for a specific plugin.
+     * @default false
+     */
+    override?: boolean;
+  };
+  /**
+   * An array of Kubb plugins that used in the generation.
+   * Each plugin may include additional configurable options(defined in the plugin itself).
+   * If a plugin depends on another plugin, an error is returned if the required dependency is missing. See pre for more details.
+   */
+  plugins: Array<Plugin>;
+  /**
+   * Devtools configuration for Kubb Studio integration.
+   */
+  devtools?: true | {
+    /**
+     * Override the Kubb Studio base URL.
+     * @default 'https://studio.kubb.dev'
+     */
+    studioUrl?: typeof DEFAULT_STUDIO_URL | (string & {});
+  };
+  /**
+   * Hooks triggered when a specific action occurs in Kubb.
+   */
+  hooks?: {
+    /**
+     * Hook that triggers at the end of all executions.
+     * Useful for running Prettier or ESLint to format/lint your code.
+     */
+    done?: string | Array<string>;
+  };
+};
+/**
+ * A type/string-pattern filter used for `include`, `exclude`, and `override` matching.
+ */
+type PatternFilter = {
+  type: string;
+  pattern: string | RegExp;
+};
+/**
+ * A pattern filter paired with partial option overrides to apply when the pattern matches.
+ */
+type PatternOverride<TOptions> = PatternFilter & {
+  options: Omit<Partial<TOptions>, 'override'>;
+};
+/**
+ * Context passed to `resolver.resolveOptions` to apply include/exclude/override filtering
+ * for a given operation or schema node.
+ */
+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): FabricFile.Path;
+  resolveFile(params: ResolverFileParams, context: ResolverContext): FabricFile.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'>;
+type PluginFactoryOptions<
+/**
+ * Name to be used for the plugin.
+ */
+TName extends string = string,
+/**
+ * Options of the plugin.
+ */
+TOptions extends object = object,
+/**
+ * Options of the plugin that can be used later on, see `options` inside your plugin config.
+ */
+TResolvedOptions extends object = TOptions,
+/**
+ * Context that you want to expose to other plugins.
+ */
+TContext = unknown,
+/**
+ * When calling `resolvePath` you can specify better types.
+ */
+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 UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name used for the plugin
+   * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
+   * @example @kubb/typescript
+   */
+  name: TOptions['name'];
+  /**
+   * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+   */
+  options: TOptions['resolvedOptions'] & {
+    output: Output;
+    include?: Array<Include>;
+    exclude: Array<Exclude>;
+    override: Array<Override<TOptions['resolvedOptions']>>;
+  };
+  /**
+   * The resolver for this plugin.
+   * Composed by `getPreset` from the preset resolver and the user's `resolver` partial override.
+   */
+  resolver?: TOptions['resolver'];
+  /**
+   * The composed transformer for this plugin.
+   * Composed by `getPreset` from the preset's transformers and the user's `transformer` visitor.
+   * When a visitor method returns `null`/`undefined`, the preset transformer's result is used instead.
+   */
+  transformer?: Visitor;
+  /**
+   * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
+   * Can be used to validate dependent plugins.
+   */
+  pre?: Array<string>;
+  /**
+   * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin is executed before these plugins.
+   */
+  post?: Array<string>;
+  /**
+   * When `apply` is defined, the plugin is only activated when `apply(config)` returns `true`.
+   * Inspired by Vite's `apply` option.
+   *
+   * @example
+   * ```ts
+   * apply: (config) => config.output.path !== 'disabled'
+   * ```
+   */
+  apply?: (config: Config) => boolean;
+  /**
+   * Expose shared helpers or data to all other plugins via `PluginContext`.
+   * The object returned is merged into the context that every plugin receives.
+   * Use the `declare global { namespace Kubb { interface PluginContext { … } } }` pattern
+   * to make the injected properties type-safe.
+   *
+   * @example
+   * ```ts
+   * inject() {
+   *   return { getOas: () => parseSpec(this.config) }
+   * }
+   * // Other plugins can then call `this.getOas()` inside buildStart()
+   * ```
+   */
+  inject?: (this: PluginContext<TOptions>) => TOptions['context'];
+};
+type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<string, object, object, unknown, object>>;
+/**
+ * Handler for a single schema node. Used by the `schema` hook on a plugin.
+ */
+type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+/**
+ * Handler for a single operation node. Used by the `operation` hook on a plugin.
+ */
+type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+/**
+ * Handler for all collected operation nodes. Used by the `operations` hook on a plugin.
+ */
+type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name used for the plugin
+   * @example @kubb/typescript
+   */
+  name: TOptions['name'];
+  /**
+   * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
+   * Can be used to validate dependent plugins.
+   */
+  pre?: Array<string>;
+  /**
+   * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin is executed before these plugins.
+   */
+  post?: Array<string>;
+  /**
+   * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+   */
+  options: TOptions['resolvedOptions'] & {
+    output: Output;
+    include?: Array<Include>;
+    exclude: Array<Exclude>;
+    override: Array<Override<TOptions['resolvedOptions']>>;
+  };
+  /**
+   * The resolver for this plugin.
+   * Composed by `getPreset` from the preset resolver and the user's `resolver` partial override.
+   */
+  resolver: TOptions['resolver'];
+  /**
+   * The composed transformer for this plugin. Accessible via `context.transformer`.
+   * Composed by `getPreset` from the preset's transformers and the user's `transformer` visitor.
+   * When a visitor method returns `null`/`undefined`, the preset transformer's result is used instead.
+   */
+  transformer?: Visitor;
+  /**
+   * When `apply` is defined, the plugin is only activated when `apply(config)` returns `true`.
+   * Inspired by Vite's `apply` option.
+   */
+  apply?: (config: Config) => boolean;
+  /**
+   * Optional semver version string for this plugin, e.g. `"1.2.3"`.
+   * Used in diagnostic messages and version-conflict detection.
+   */
+  version?: string;
+  buildStart: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  /**
+   * Called once per plugin after all files have been written to disk.
+   * Use this for post-processing, copying assets, or generating summary reports.
+   */
+  buildEnd: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  /**
+   * Called for each schema node during the AST walk.
+   * Return a React element, an array of `FabricFile.File`, or `void` for manual handling.
+   * Nodes matching `exclude`/`include` filters are skipped automatically.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  schema?: SchemaHook<TOptions>;
+  /**
+   * Called for each operation node during the AST walk.
+   * Return a React element, an array of `FabricFile.File`, or `void` for manual handling.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  operation?: OperationHook<TOptions>;
+  /**
+   * Called once after all operations have been walked, with the full collected set.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  operations?: OperationsHook<TOptions>;
+  /**
+   * Expose shared helpers or data to all other plugins via `PluginContext`.
+   * The returned object is merged into the context received by every plugin.
+   */
+  inject: (this: PluginContext<TOptions>) => TOptions['context'];
+};
+type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
+type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Called once per plugin at the start of its processing phase, before schema/operation/operations hooks run.
+   * Use this to set up shared state, fetch remote data, or perform any async initialization.
+   * @type hookParallel
+   */
+  buildStart?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  /**
+   * Called once per plugin after all files have been written to disk.
+   * Use this for post-processing, copying assets, or generating summary reports.
+   * @type hookParallel
+   */
+  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
+  /**
+   * Called for each schema node during the AST walk.
+   * Return a React element (`<File>...</File>`), an array of `FabricFile.File` objects,
+   * or `void` to handle file writing manually via `this.upsertFile`.
+   * Nodes matching `exclude` / `include` filters are skipped automatically.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  schema?: SchemaHook<TOptions>;
+  /**
+   * Called for each operation node during the AST walk.
+   * Return a React element (`<File>...</File>`), an array of `FabricFile.File` objects,
+   * or `void` to handle file writing manually via `this.upsertFile`.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  operation?: OperationHook<TOptions>;
+  /**
+   * Called once after all operation nodes have been walked, with the full collection.
+   * Useful for generating index/barrel files per group or aggregate operation handlers.
+   *
+   * For multiple generators, use `composeGenerators` inside the plugin factory.
+   */
+  operations?: OperationsHook<TOptions>;
+  /**
+   * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
+   * Options can als be included.
+   * @type hookFirst
+   * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
+   * @deprecated this will be replaced by resolvers
+   */
+  resolvePath?: (this: PluginContext<TOptions>, baseName: FabricFile.BaseName, mode?: FabricFile.Mode, options?: TOptions['resolvePathOptions']) => FabricFile.Path;
+  /**
+   * Resolve to a name based on a string.
+   * 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;
+};
+type PluginLifecycleHooks = keyof PluginLifecycle;
+type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
+type ResolvePathParams<TOptions = object> = {
+  pluginName?: string;
+  baseName: FabricFile.BaseName;
+  mode?: FabricFile.Mode;
+  /**
+   * Options to be passed to 'resolvePath' 3th parameter
+   */
+  options?: TOptions;
+};
+type ResolveNameParams = {
+  name: string;
+  pluginName?: string;
+  /**
+   * Specifies the type of entity being named.
+   * - 'file' customizes the name of the created file (uses camelCase).
+   * - 'function' customizes the exported function names (uses camelCase).
+   * - 'type' customizes TypeScript types (uses PascalCase).
+   * - 'const' customizes variable names (uses camelCase).
+   * @default undefined
+   */
+  type?: 'file' | 'function' | 'type' | 'const';
+};
+type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  fabric: Fabric;
+  config: Config;
+  /**
+   * Absolute path to the output directory for the current plugin.
+   * Shorthand for `path.resolve(config.root, config.output.path)`.
+   */
+  root: string;
+  /**
+   * Returns the output mode for the given output config.
+   * Returns `'single'` when `output.path` has a file extension, `'split'` otherwise.
+   * Shorthand for `getMode(path.resolve(this.root, output.path))`.
+   */
+  getMode: (output: {
+    path: string;
+  }) => FabricFile.Mode;
+  driver: PluginDriver;
+  /**
+   * Get a plugin by name. Returns the plugin typed via `Kubb.PluginRegistry` when
+   * the name is a registered key, otherwise returns the generic `Plugin`.
+   */
+  getPlugin<TName extends keyof Kubb.PluginRegistry>(name: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
+  getPlugin(name: string): Plugin | undefined;
+  /**
+   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
+   * Useful for enforcing dependencies inside `buildStart()`.
+   */
+  requirePlugin<TName extends keyof Kubb.PluginRegistry>(name: TName): Plugin<Kubb.PluginRegistry[TName]>;
+  requirePlugin(name: string): Plugin;
+  /**
+   * Only add when the file does not exist yet
+   */
+  addFile: (...file: Array<FabricFile.File>) => Promise<void>;
+  /**
+   * merging multiple sources into the same output file
+   */
+  upsertFile: (...file: Array<FabricFile.File>) => Promise<void>;
+  /**
+   * @deprecated use this.warn, this.error, this.info instead
+   */
+  events: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TOptions>;
+  /**
+   * Resolver for the current plugin. Shorthand for `plugin.resolver`.
+   */
+  resolver: TOptions['resolver'];
+  /**
+   * Composed transformer for the current plugin. Shorthand for `plugin.transformer`.
+   * Apply with `transform(node, context.transformer)` to pre-process AST nodes before printing.
+   */
+  transformer: Visitor | undefined;
+  /**
+   * Emit a warning via the build event system.
+   * Shorthand for `this.events.emit('warn', message)`.
+   */
+  warn: (message: string) => void;
+  /**
+   * Emit an error via the build event system.
+   * Shorthand for `this.events.emit('error', error)`.
+   */
+  error: (error: string | Error) => void;
+  /**
+   * Emit an info message via the build event system.
+   * Shorthand for `this.events.emit('info', message)`.
+   */
+  info: (message: string) => void;
+  /**
+   * 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>;
+} & ({
+  /**
+   * 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;
+/**
+ * Narrowed `PluginContext` used as the `this` type inside generator and plugin AST hook methods.
+ *
+ * Generators and the `schema`/`operation`/`operations` plugin hooks are only invoked from
+ * `runPluginAstHooks`, which already guards against a missing adapter. This type reflects
+ * that guarantee — `this.adapter` and `this.rootNode` are always defined, so no runtime
+ * checks or casts are needed inside the method bodies.
+ */
+type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Omit<PluginContext<TOptions>, 'adapter' | 'rootNode'> & {
+  adapter: Adapter;
+  rootNode: RootNode;
+};
+/**
+ * Specify the export location for the files and define the behavior of the output
+ */
+type Output<_TOptions = unknown> = {
+  /**
+   * Path to the output folder or file that will contain the generated code
+   */
+  path: string;
+  /**
+   * Define what needs to be exported, here you can also disable the export of barrel files
+   * @default 'named'
+   */
+  barrelType?: BarrelType | false;
+  /**
+   * Add a banner text in the beginning of every file
+   */
+  banner?: string | ((node?: RootNode) => string);
+  /**
+   * Add a footer text in the beginning of every file
+   */
+  footer?: string | ((node?: RootNode) => string);
+  /**
+   * Whether to override existing external files if they already exist.
+   * @default false
+   */
+  override?: boolean;
+};
+type UserGroup = {
+  /**
+   * Defines the type where to group the files.
+   * - 'tag' groups files by OpenAPI tags.
+   * - 'path' groups files by OpenAPI paths.
+   * @default undefined
+   */
+  type: 'tag' | 'path';
+  /**
+   * Return the name of a group based on the group name, this is used for the file and name generation.
+   */
+  name?: (context: {
+    group: string;
+  }) => string;
+};
+type Group = {
+  /**
+   * Defines the type where to group the files.
+   * - 'tag' groups files by OpenAPI tags.
+   * - 'path' groups files by OpenAPI paths.
+   * @default undefined
+   */
+  type: 'tag' | 'path';
+  /**
+   * Return the name of a group based on the group name, this is used for the file and name generation.
+   */
+  name: (context: {
+    group: string;
+  }) => string;
+};
+type LoggerOptions = {
+  /**
+   * @default 3
+   */
+  logLevel: (typeof logLevel)[keyof typeof logLevel];
+};
+/**
+ * Shared context passed to all plugins, parsers, and Fabric internals.
+ */
+type LoggerContext = AsyncEventEmitter<KubbEvents>;
+type Logger<TOptions extends LoggerOptions = LoggerOptions> = {
+  name: string;
+  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, a resolver, 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;
+  /**
+   * The resolver used by this preset.
+   */
+  resolver: 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>>;
+  /**
+   * Optional printer factory used by this preset.
+   * The generator calls this function at render-time to produce a configured printer instance.
+   */
+  printer?: (options: any) => Printer;
+};
+/**
+ * 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: FabricFile.BaseName;
+  pathMode?: FabricFile.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: FabricFile.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>;
+/**
+ * Hook dispatch strategy used by the `PluginDriver`.
+ *
+ * - `hookFirst` — stops at the first non-null result.
+ * - `hookForPlugin` — calls only the matching plugin.
+ * - `hookParallel` — calls all plugins concurrently.
+ * - `hookSeq` — calls all plugins in order, threading the result.
+ */
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+  result: Result;
+  plugin: Plugin;
+};
+type Options = {
+  fabric: Fabric;
+  events: AsyncEventEmitter<KubbEvents>;
+  /**
+   * @default Number.POSITIVE_INFINITY
+   */
+  concurrency?: number;
+};
+/**
+ * Parameters accepted by `PluginDriver.getFile` to resolve a generated file descriptor.
+ */
+type GetFileOptions<TOptions = object> = {
+  name: string;
+  mode?: FabricFile.Mode;
+  extname: FabricFile.Extname;
+  pluginName: string;
+  options?: TOptions;
+};
+/**
+ * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+ *
+ * @example
+ * ```ts
+ * getMode('src/gen/types.ts')  // 'single'
+ * getMode('src/gen/types')     // 'split'
+ * ```
+ */
+declare function getMode(fileOrFolder: string | undefined | null): FabricFile.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;
+  readonly plugins: Map<string, Plugin>;
+  constructor(config: Config, options: Options);
+  get events(): AsyncEventEmitter<KubbEvents>;
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  getFile<TOptions = object>({
+    name,
+    mode,
+    extname,
+    pluginName,
+    options
+  }: GetFileOptions<TOptions>): FabricFile.File<{
+    pluginName: string;
+  }>;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => FabricFile.Path;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  resolveName: (params: ResolveNameParams) => string;
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPlugin<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPluginSync<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Array<ReturnType<ParseResult<H>>> | null;
+  /**
+   * Returns the first non-null result.
+   */
+  hookFirst<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): Promise<SafeParseResult<H>>;
+  /**
+   * Returns the first non-null result.
+   */
+  hookFirstSync<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): SafeParseResult<H> | null;
+  /**
+   * Runs all plugins in parallel based on `this.plugin` order and `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>;
+  getPlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
+  getPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions> | undefined;
+  /**
+   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
+   */
+  requirePlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]>;
+  requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
+}
+//#endregion
+export { defineGenerator as $, Preset as A, Resolver as B, Plugin as C, PluginLifecycleHooks as D, PluginLifecycle as E, ResolveBannerContext as F, UserConfig as G, ResolverFileParams as H, ResolveNameParams as I, UserPlugin as J, UserGroup as K, ResolveOptionsContext as L, Printer$1 as M, PrinterFactoryOptions as N, PluginParameter as O, PrinterPartial as P, Generator as Q, ResolvePathOptions as R, Override as S, PluginFactoryOptions as T, ResolverPathParams as U, ResolverContext as V, SchemaHook as W, UserResolver as X, UserPluginWithLifeCycle as Y, KubbEvents as Z, LoggerContext as _, AdapterSource as a, logLevel as at, OperationsHook as b, Config as c, GeneratorContext as d, mergeGenerators as et, Group as f, Logger as g, InputPath as h, AdapterFactoryOptions as i, linters as it, Presets as j, PluginWithLifeCycle as k, DevtoolsOptions as l, InputData as m, getMode as n, createStorage as nt, BarrelType as o, PossiblePromise as ot, Include as p, UserLogger as q, Adapter as r, formatters as rt, CompatibilityPreset as s, AsyncEventEmitter as st, PluginDriver as t, Storage as tt, Exclude as u, LoggerOptions as v, PluginContext as w, Output as x, OperationHook as y, ResolvePathParams as z };
+//# sourceMappingURL=PluginDriver-D110FoJ-.d.ts.map