@kubb/core 5.0.0-alpha.4 → 5.0.0-alpha.41

package/dist/types-C6NCtNqM.d.ts

@@ -0,0 +1,2151 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { FileNode, HttpMethod, ImportNode, InputNode, Node, OperationNode, SchemaNode, Visitor } from "@kubb/ast";
+
+//#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;
+  /**
+   * Returns the number of listeners registered for `eventName`.
+   *
+   * @example
+   * ```ts
+   * emitter.on('build', handler)
+   * emitter.listenerCount('build') // 1
+   * ```
+   */
+  listenerCount<TEventName extends keyof TEvents & string>(eventName: TEventName): number;
+  /**
+   * 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;
+};
+//#endregion
+//#region src/createRenderer.d.ts
+/**
+ * Minimal interface any Kubb renderer must satisfy.
+ *
+ * The generic `TElement` is the type of the element the renderer accepts —
+ * e.g. `KubbReactElement` for `@kubb/renderer-jsx`, or a custom type for
+ * your own renderer.  Defaults to `unknown` so that generators which do not
+ * care about the element type continue to work without specifying it.
+ *
+ * This allows core to drive rendering without a hard dependency on
+ * `@kubb/renderer-jsx` or any specific renderer implementation.
+ */
+type Renderer<TElement = unknown> = {
+  render(element: TElement): Promise<void>;
+  unmount(error?: Error | number | null): void;
+  readonly files: Array<FileNode>;
+};
+/**
+ * A factory function that produces a fresh {@link Renderer} per render.
+ *
+ * Generators use this to declare which renderer handles their output.
+ */
+type RendererFactory<TElement = unknown> = () => Renderer<TElement>;
+/**
+ * Creates a renderer factory for use in generator definitions.
+ *
+ * Wrap your renderer factory function with this helper to register it as the
+ * renderer for a generator. Core will call this factory once per render cycle
+ * to obtain a fresh renderer instance.
+ *
+ * @example
+ * ```ts
+ * // packages/renderer-jsx/src/index.ts
+ * export const jsxRenderer = createRenderer(() => {
+ *   const runtime = new Runtime()
+ *   return {
+ *     async render(element) { await runtime.render(element) },
+ *     get files() { return runtime.nodes },
+ *     unmount(error) { runtime.unmount(error) },
+ *   }
+ * })
+ *
+ * // packages/plugin-zod/src/generators/zodGenerator.tsx
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ * export const zodGenerator = defineGenerator<PluginZod>({
+ *   name: 'zod',
+ *   renderer: jsxRenderer,
+ *   schema(node, options) { return <File ...>...</File> },
+ * })
+ * ```
+ */
+declare function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement>;
+//#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 receives the AST node as the first argument and a typed
+ * `ctx` object as the second, giving access to `ctx.config`, `ctx.resolver`,
+ * `ctx.adapter`, `ctx.options`, `ctx.upsertFile`, etc.
+ *
+ * Generators that return renderer elements (e.g. JSX) must declare a `renderer`
+ * factory so that core knows how to process the output without coupling core
+ * to any specific renderer package.
+ *
+ * Return a renderer element, an array of `FileNode`, or `void` to handle file
+ * writing manually via `ctx.upsertFile`.
+ *
+ * @example
+ * ```ts
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ *
+ * export const typeGenerator = defineGenerator<PluginTs>({
+ *   name: 'typescript',
+ *   renderer: jsxRenderer,
+ *   schema(node, ctx) {
+ *     const { adapter, resolver, root, options } = ctx
+ *     return <File ...><Type node={node} resolver={resolver} /></File>
+ *   },
+ *   operation(node, ctx) {
+ *     const { options } = ctx
+ *     return <File ...><OperationType node={node} /></File>
+ *   },
+ * })
+ * ```
+ */
+type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown> = {
+  /**
+   * Used in diagnostic messages and debug output.
+   */
+  name: string;
+  /**
+   * Optional renderer factory that produces a {@link Renderer} for each render cycle.
+   *
+   * Generators that return renderer elements (e.g. JSX via `@kubb/renderer-jsx`) must set this
+   * to the matching renderer factory (e.g. `jsxRenderer` from `@kubb/renderer-jsx`).
+   *
+   * Generators that only return `Array<FileNode>` or `void` do not need to set this.
+   *
+   * Set `renderer: null` to explicitly opt out of rendering even when the parent plugin
+   * declares a `renderer` (overrides the plugin-level fallback).
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * export const myGenerator = defineGenerator<PluginTs>({
+   *   renderer: jsxRenderer,
+   *   schema(node, ctx) { return <File ...>...</File> },
+   * })
+   * ```
+   */
+  renderer?: RendererFactory<TElement> | null;
+  /**
+   * Called for each schema node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  schema?: (node: SchemaNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+  /**
+   * Called for each operation node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  operation?: (node: OperationNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+  /**
+   * Called once after all operations have been walked.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the plugin-level options for the batch call.
+   */
+  operations?: (nodes: Array<OperationNode>, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>;
+};
+/**
+ * Defines a generator. Returns the object as-is with correct `this` typings.
+ * `applyHookResult` handles renderer elements and `File[]` uniformly using
+ * the generator's declared `renderer` factory.
+ */
+declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown>(generator: Generator<TOptions, TElement>): Generator<TOptions, TElement>;
+//#endregion
+//#region src/defineParser.d.ts
+type PrintOptions = {
+  extname?: FileNode['extname'];
+};
+type Parser<TMeta extends object = any> = {
+  name: string;
+  /**
+   * File extensions this parser handles.
+   * Use `undefined` to create a catch-all fallback parser.
+   *
+   * @example Handled extensions
+   * `['.ts', '.js']`
+   */
+  extNames: Array<FileNode['extname']> | undefined;
+  /**
+   * Convert a resolved file to a string.
+   */
+  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string;
+};
+/**
+ * Defines a parser with type safety.
+ *
+ * Use this function to create parsers that transform generated files to strings
+ * based on their extension.
+ *
+ * @example
+ * ```ts
+ * import { defineParser } from '@kubb/core'
+ *
+ * export const jsonParser = defineParser({
+ *   name: 'json',
+ *   extNames: ['.json'],
+ *   parse(file) {
+ *     const { extractStringsFromNodes } = await import('@kubb/ast')
+ *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
+ *   },
+ * })
+ * ```
+ */
+declare function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta>;
+//#endregion
+//#region src/FileManager.d.ts
+/**
+ * In-memory file store for generated files.
+ *
+ * Files with the same `path` are merged — sources, imports, and exports are concatenated.
+ * The `files` getter returns all stored files sorted by path length (shortest first).
+ *
+ * @example
+ * ```ts
+ * import { FileManager } from '@kubb/core'
+ *
+ * const manager = new FileManager()
+ * manager.upsert(myFile)
+ * console.log(manager.files) // all stored files
+ * ```
+ */
+declare class FileManager {
+  #private;
+  /**
+   * Adds one or more files. Files with the same path are merged — sources, imports,
+   * and exports from all calls with the same path are concatenated together.
+   */
+  add(...files: Array<FileNode>): Array<FileNode>;
+  /**
+   * Adds or merges one or more files.
+   * If a file with the same path already exists, its sources/imports/exports are merged together.
+   */
+  upsert(...files: Array<FileNode>): Array<FileNode>;
+  getByPath(path: string): FileNode | null;
+  deleteByPath(path: string): void;
+  clear(): void;
+  /**
+   * All stored files, sorted by path length (shorter paths first).
+   * Barrel/index files (e.g. index.ts) are sorted last within each length bucket.
+   */
+  get files(): Array<FileNode>;
+}
+//#endregion
+//#region src/PluginDriver.d.ts
+type RequiredPluginLifecycle = Required<PluginLifecycle>;
+/**
+ * Hook dispatch strategy used by the `PluginDriver`.
+ *
+ * - `hookFirst` — stops at the first non-null result.
+ * - `hookForPlugin` — calls only the matching plugin.
+ * - `hookParallel` — calls all plugins concurrently.
+ * - `hookSeq` — calls all plugins in order, threading the result.
+ */
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+  result: Result;
+  plugin: Plugin;
+};
+type Options = {
+  hooks?: AsyncEventEmitter<KubbHooks>;
+  /**
+   * @default Number.POSITIVE_INFINITY
+   */
+  concurrency?: number;
+};
+/**
+ * Parameters accepted by `PluginDriver.getFile` to resolve a generated file descriptor.
+ */
+type GetFileOptions<TOptions = object> = {
+  name: string;
+  mode?: 'single' | 'split';
+  extname: FileNode['extname'];
+  pluginName: string;
+  options?: TOptions;
+};
+declare class PluginDriver {
+  #private;
+  readonly config: Config;
+  readonly options: Options;
+  /**
+   * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+   *
+   * @example
+   * ```ts
+   * PluginDriver.getMode('src/gen/types.ts')  // 'single'
+   * PluginDriver.getMode('src/gen/types')     // 'split'
+   * ```
+   */
+  static getMode(fileOrFolder: string | undefined | null): 'single' | 'split';
+  /**
+   * The universal `@kubb/ast` `InputNode` produced by the adapter, set by
+   * the build pipeline after the adapter's `parse()` resolves.
+   */
+  inputNode: InputNode | undefined;
+  adapter: Adapter | undefined;
+  /**
+   * Central file store for all generated files.
+   * Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
+   * add files; this property gives direct read/write access when needed.
+   */
+  readonly fileManager: FileManager;
+  readonly plugins: Map<string, Plugin>;
+  constructor(config: Config, options: Options);
+  get hooks(): AsyncEventEmitter<KubbHooks>;
+  /**
+   * Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
+   *
+   * For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
+   * plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
+   * `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
+   *
+   * All other hooks are iterated and registered directly as pass-through listeners.
+   * Any event key present in the global `KubbHooks` interface can be subscribed to.
+   *
+   * External tooling can subscribe to any of these events via `hooks.on(...)` to observe
+   * the plugin lifecycle without modifying plugin behavior.
+   */
+  registerPluginHooks(hookPlugin: HookStylePlugin, normalizedPlugin: Plugin): void;
+  /**
+   * Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
+   * can configure generators, resolvers, transformers and renderers before `buildStart` runs.
+   *
+   * Call this once from `safeBuild` before the plugin execution loop begins.
+   */
+  emitSetupHooks(): Promise<void>;
+  /**
+   * Registers a generator for the given plugin on the shared event emitter.
+   *
+   * The generator's `schema`, `operation`, and `operations` methods are registered as
+   * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
+   * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
+   * so that generators from different plugins do not cross-fire.
+   *
+   * The renderer resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
+   * Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
+   * declares a renderer.
+   *
+   * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
+   */
+  registerGenerator(pluginName: string, gen: Generator): void;
+  /**
+   * Returns `true` when at least one generator was registered for the given plugin
+   * via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+   *
+   * Used by the build loop to decide whether to walk the AST and emit generator events
+   * for a plugin that has no static `plugin.generators`.
+   */
+  hasRegisteredGenerators(pluginName: string): boolean;
+  dispose(): void;
+  setPluginResolver(pluginName: string, partial: Partial<Resolver>): void;
+  getResolver(pluginName: string): Resolver;
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, unknown>;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  getFile<TOptions = object>({
+    name,
+    mode,
+    extname,
+    pluginName,
+    options
+  }: GetFileOptions<TOptions>): FileNode<{
+    pluginName: string;
+  }>;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => string;
+  /**
+   * @deprecated use resolvers context instead
+   */
+  resolveName: (params: ResolveNameParams) => string;
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPlugin<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Promise<Array<ReturnType<ParseResult<H>> | null>>;
+  /**
+   * Run a specific hookName for plugin x.
+   */
+  hookForPluginSync<H extends PluginLifecycleHooks>({
+    pluginName,
+    hookName,
+    parameters
+  }: {
+    pluginName: string;
+    hookName: H;
+    parameters: PluginParameter<H>;
+  }): Array<ReturnType<ParseResult<H>>> | null;
+  /**
+   * Returns the first non-null result.
+   */
+  hookFirst<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): Promise<SafeParseResult<H>>;
+  /**
+   * Returns the first non-null result.
+   */
+  hookFirstSync<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    skipped
+  }: {
+    hookName: H;
+    parameters: PluginParameter<H>;
+    skipped?: ReadonlySet<Plugin> | null;
+  }): SafeParseResult<H> | null;
+  /**
+   * Runs all plugins in parallel based on `this.plugin` order and `dependencies` settings.
+   */
+  hookParallel<H extends PluginLifecycleHooks, TOutput = void>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
+  }): Promise<Awaited<TOutput>[]>;
+  /**
+   * Execute a lifecycle hook sequentially for all plugins that implement it.
+   */
+  hookSeq<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters
+  }: {
+    hookName: H;
+    parameters?: PluginParameter<H>;
+  }): Promise<void>;
+  getPlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]> | undefined;
+  getPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions> | undefined;
+  /**
+   * Like `getPlugin` but throws a descriptive error when the plugin is not found.
+   */
+  requirePlugin<TName extends keyof Kubb.PluginRegistry>(pluginName: TName): Plugin<Kubb.PluginRegistry[TName]>;
+  requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
+}
+//#endregion
+//#region src/createKubb.d.ts
+/**
+ * Full output produced by a successful or failed build.
+ */
+type BuildOutput = {
+  /**
+   * Plugins that threw during installation, paired with the caught error.
+   */
+  failedPlugins: Set<{
+    plugin: Plugin;
+    error: Error;
+  }>;
+  files: Array<FileNode>;
+  driver: PluginDriver;
+  /**
+   * Elapsed time in milliseconds for each plugin, keyed by plugin name.
+   */
+  pluginTimings: Map<string, number>;
+  error?: Error;
+  /**
+   * Raw generated source, keyed by absolute file path.
+   */
+  sources: Map<string, string>;
+};
+type CreateKubbOptions = {
+  hooks?: AsyncEventEmitter<KubbHooks>;
+};
+/**
+ * Creates a Kubb instance bound to a single config entry.
+ *
+ * Accepts a user-facing config shape and resolves it to a full {@link Config} during
+ * `setup()`. The instance then holds shared state (`hooks`, `sources`, `driver`, `config`)
+ * across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
+ * calling `setup()` or `build()`.
+ *
+ * @example
+ * ```ts
+ * const kubb = createKubb(userConfig)
+ *
+ * kubb.hooks.on('kubb:plugin:end', (plugin, { duration }) => {
+ *   console.log(`${plugin.name} completed in ${duration}ms`)
+ * })
+ *
+ * const { files, failedPlugins } = await kubb.safeBuild()
+ * ```
+ */
+declare function createKubb(userConfig: UserConfig, options?: CreateKubbOptions): Kubb$1;
+//#endregion
+//#region src/Kubb.d.ts
+type DebugInfo = {
+  date: Date;
+  logs: Array<string>;
+  fileName?: string;
+};
+type HookProgress<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H;
+  plugins: Array<Plugin>;
+};
+type HookExecution<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: Array<unknown>;
+  output?: unknown;
+};
+type HookResult<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  duration: number;
+  strategy: Strategy;
+  hookName: H;
+  plugin: Plugin;
+  parameters?: Array<unknown>;
+  output?: unknown;
+};
+/**
+ * The instance returned by {@link createKubb}.
+ */
+type Kubb$1 = {
+  /**
+   * The shared event emitter. Attach listeners here before calling `setup()` or `build()`.
+   */
+  readonly hooks: AsyncEventEmitter<KubbHooks>;
+  /**
+   * Raw generated source, keyed by absolute file path.
+   * Populated after a successful `build()` or `safeBuild()` call.
+   */
+  readonly sources: Map<string, string>;
+  /**
+   * The plugin driver. Available after `setup()` has been called.
+   */
+  readonly driver: PluginDriver | undefined;
+  /**
+   * The resolved config with applied defaults. Available after `setup()` has been called.
+   */
+  readonly config: Config | undefined;
+  /**
+   * Initializes all Kubb infrastructure: validates input, applies config defaults,
+   * runs the adapter, and creates the PluginDriver.
+   *
+   * Calling `build()` or `safeBuild()` without calling `setup()` first will
+   * automatically invoke `setup()` before proceeding.
+   */
+  setup(): Promise<void>;
+  /**
+   * Runs a full Kubb build and throws on any error or plugin failure.
+   * Automatically calls `setup()` if it has not been called yet.
+   */
+  build(): Promise<BuildOutput>;
+  /**
+   * Runs a full Kubb build and captures errors instead of throwing.
+   * Automatically calls `setup()` if it has not been called yet.
+   */
+  safeBuild(): Promise<BuildOutput>;
+};
+/**
+ * Events emitted during the Kubb code generation lifecycle.
+ * These events can be listened to for logging, progress tracking, and custom integrations.
+ *
+ * @example
+ * ```typescript
+ * import type { AsyncEventEmitter } from '@internals/utils'
+ * import type { KubbHooks } from '@kubb/core'
+ *
+ * const hooks: AsyncEventEmitter<KubbHooks> = new AsyncEventEmitter()
+ *
+ * hooks.on('kubb:lifecycle:start', () => {
+ *   console.log('Starting Kubb generation')
+ * })
+ *
+ * hooks.on('kubb:plugin:end', (plugin, { duration }) => {
+ *   console.log(`Plugin ${plugin.name} completed in ${duration}ms`)
+ * })
+ * ```
+ */
+interface KubbHooks {
+  /**
+   * Emitted at the beginning of the Kubb lifecycle, before any code generation starts.
+   */
+  'kubb:lifecycle:start': [version: string];
+  /**
+   * Emitted at the end of the Kubb lifecycle, after all code generation is complete.
+   */
+  'kubb:lifecycle:end': [];
+  /**
+   * Emitted when configuration loading starts.
+   */
+  'kubb:config:start': [];
+  /**
+   * Emitted when configuration loading is complete.
+   */
+  'kubb:config:end': [configs: Array<Config>];
+  /**
+   * Emitted when code generation phase starts.
+   */
+  'kubb:generation:start': [config: Config];
+  /**
+   * Emitted when code generation phase completes.
+   */
+  'kubb:generation:end': [config: Config, files: Array<FileNode>, sources: Map<string, string>];
+  /**
+   * Emitted with a summary of the generation results.
+   * Contains summary lines, title, and success status.
+   */
+  'kubb:generation:summary': [config: Config, {
+    failedPlugins: Set<{
+      plugin: Plugin;
+      error: Error;
+    }>;
+    status: 'success' | 'failed';
+    hrStart: [number, number];
+    filesCreated: number;
+    pluginTimings?: Map<Plugin['name'], number>;
+  }];
+  /**
+   * Emitted when code formatting starts (e.g., running Biome or Prettier).
+   */
+  'kubb:format:start': [];
+  /**
+   * Emitted when code formatting completes.
+   */
+  'kubb:format:end': [];
+  /**
+   * Emitted when linting starts.
+   */
+  'kubb:lint:start': [];
+  /**
+   * Emitted when linting completes.
+   */
+  'kubb:lint:end': [];
+  /**
+   * Emitted when plugin hooks execution starts.
+   */
+  'kubb:hooks:start': [];
+  /**
+   * Emitted when plugin hooks execution completes.
+   */
+  'kubb:hooks:end': [];
+  /**
+   * Emitted when a single hook execution starts (e.g., format or lint).
+   * The callback should be invoked when the command completes.
+   */
+  'kubb:hook:start': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+  }];
+  /**
+   * Emitted when a single hook execution completes.
+   */
+  'kubb:hook:end': [{
+    id?: string;
+    command: string;
+    args?: readonly string[];
+    success: boolean;
+    error: Error | null;
+  }];
+  /**
+   * Emitted when a new version of Kubb is available.
+   */
+  'kubb:version:new': [currentVersion: string, latestVersion: string];
+  /**
+   * Informational message event.
+   */
+  'kubb:info': [message: string, info?: string];
+  /**
+   * Error event. Emitted when an error occurs during code generation.
+   */
+  'kubb:error': [error: Error, meta?: Record<string, unknown>];
+  /**
+   * Success message event.
+   */
+  'kubb:success': [message: string, info?: string];
+  /**
+   * Warning message event.
+   */
+  'kubb:warn': [message: string, info?: string];
+  /**
+   * Debug event for detailed logging.
+   * Contains timestamp, log messages, and optional filename.
+   */
+  'kubb:debug': [info: DebugInfo];
+  /**
+   * Emitted when file processing starts.
+   * Contains the list of files to be processed.
+   */
+  'kubb:files:processing:start': [files: Array<FileNode>];
+  /**
+   * Emitted for each file being processed, providing progress updates.
+   * Contains processed count, total count, percentage, and file details.
+   */
+  'kubb: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: FileNode;
+    /**
+     * Kubb configuration
+     * Provides access to the current config during file processing.
+     */
+    config: Config;
+  }];
+  /**
+   * Emitted when file processing completes.
+   * Contains the list of processed files.
+   */
+  'kubb:files:processing:end': [files: Array<FileNode>];
+  /**
+   * Emitted when a plugin starts executing.
+   */
+  'kubb:plugin:start': [plugin: Plugin];
+  /**
+   * Emitted when a plugin completes execution.
+   * Duration in ms.
+   */
+  'kubb: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.
+   */
+  'kubb:plugins:hook:progress:start': [progress: HookProgress];
+  /**
+   * Emitted when plugin hook progress tracking ends.
+   * Contains the hook name that completed.
+   */
+  'kubb:plugins:hook:progress:end': [{
+    hookName: PluginLifecycleHooks;
+  }];
+  /**
+   * Emitted when a plugin hook starts processing.
+   * Contains strategy, hook name, plugin, parameters, and output.
+   */
+  'kubb:plugins:hook:processing:start': [execution: HookExecution];
+  /**
+   * Emitted when a plugin hook completes processing.
+   * Contains duration, strategy, hook name, plugin, parameters, and output.
+   */
+  'kubb:plugins:hook:processing:end': [result: HookResult];
+  /**
+   * Fired once — before any plugin's `buildStart` runs — so that hook-style plugins
+   * can register generators, configure resolvers/transformers/renderers, or inject
+   * extra files.  All `kubb:plugin:setup` handlers registered via `definePlugin` receive
+   * a plugin-specific context (with the correct `addGenerator` closure).
+   * External tooling can observe this event via `hooks.on('kubb:plugin:setup', …)`.
+   */
+  'kubb:plugin:setup': [ctx: KubbPluginSetupContext];
+  /**
+   * Fired immediately before the plugin execution loop begins.
+   * The adapter has already parsed the source and `inputNode` is available.
+   */
+  'kubb:build:start': [ctx: KubbBuildStartContext];
+  /**
+   * Fired after all files have been written to disk.
+   */
+  'kubb:build:end': [ctx: KubbBuildEndContext];
+  /**
+   * Emitted for each schema node during the AST walk.
+   * Generator listeners registered via `addGenerator()` in `kubb:plugin:setup` respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the per-node resolved options (after exclude/include/override).
+   */
+  'kubb:generate:schema': [node: SchemaNode, ctx: GeneratorContext];
+  /**
+   * Emitted for each operation node during the AST walk.
+   * Generator listeners registered via `addGenerator()` in `kubb:plugin:setup` respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the per-node resolved options (after exclude/include/override).
+   */
+  'kubb:generate:operation': [node: OperationNode, ctx: GeneratorContext];
+  /**
+   * Emitted once after all operations have been walked, with the full collected array.
+   * Generator listeners with an `operations()` method respond to this event.
+   * The `ctx.plugin.name` identifies which plugin is driving the current walk.
+   * `ctx.options` carries the plugin-level resolved options for the batch call.
+   */
+  'kubb:generate:operations': [nodes: Array<OperationNode>, ctx: GeneratorContext];
+}
+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 {}
+  }
+}
+//#endregion
+//#region src/definePlugin.d.ts
+/**
+ * Base hook handlers for all events except `kubb:plugin:setup`.
+ * These handlers have identical signatures regardless of the plugin's
+ * `PluginFactoryOptions` generic — they are split out so that the
+ * interface below only needs to override the one event that depends on
+ * the plugin type.
+ */
+type PluginHooksBase = { [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void> };
+/**
+ * Plugin hook handlers.
+ *
+ * `kubb:plugin:setup` is typed with the plugin's own `PluginFactoryOptions` so
+ * `ctx.setResolver`, `ctx.setOptions`, `ctx.options` etc. use the correct types.
+ *
+ * Uses interface + method shorthand for `kubb:plugin:setup`
+ * checking, allowing `PluginHooks<PluginTs>` to be assignable to `PluginHooks`.
+ *
+ * @template TFactory - The plugin's `PluginFactoryOptions` type.
+ */
+interface PluginHooks<TFactory extends PluginFactoryOptions = PluginFactoryOptions> extends PluginHooksBase {
+  'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>;
+}
+/**
+ * A hook-style plugin object produced by `definePlugin`.
+ * Instead of flat lifecycle methods, it groups all handlers under a `hooks:` property
+ * (matching Astro's integration naming convention).
+ *
+ * @template TFactory - The plugin's `PluginFactoryOptions` type.
+ */
+type HookStylePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name for the plugin, following the same naming convention as `createPlugin`.
+   */
+  name: string;
+  /**
+   * Plugins that must be registered before this plugin executes.
+   * An error is thrown at startup when any listed dependency is missing.
+   */
+  dependencies?: Array<string>;
+  /**
+   * The options passed by the user when calling the plugin factory.
+   */
+  options?: TFactory['options'];
+  /**
+   * Lifecycle event handlers for this plugin.
+   * Any event from the global `KubbHooks` map can be subscribed to here.
+   */
+  hooks: PluginHooks<TFactory>;
+};
+/**
+ * Creates a plugin factory using the new hook-style (`hooks:`) API.
+ *
+ * The returned factory is called with optional options and produces a `HookStylePlugin`
+ * that coexists with plugins created via the legacy `createPlugin` API in the same
+ * `kubb.config.ts`.
+ *
+ * Lifecycle handlers are registered on the `PluginDriver`'s `AsyncEventEmitter`, enabling
+ * both the plugin's own handlers and external tooling (CLI, devtools) to observe every event.
+ *
+ * @example
+ * ```ts
+ * // With PluginFactoryOptions (recommended for real plugins)
+ * export const pluginTs = definePlugin<PluginTs>((options) => ({
+ *   name: 'plugin-ts',
+ *   hooks: {
+ *     'kubb:plugin:setup'(ctx) {
+ *       ctx.setResolver(resolverTs)  // typed as Partial<ResolverTs>
+ *     },
+ *   },
+ * }))
+ * ```
+ */
+declare function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(factory: (options: TFactory['options']) => HookStylePlugin<TFactory>): (options?: TFactory['options']) => HookStylePlugin<TFactory>;
+//#endregion
+//#region src/utils/getBarrelFiles.d.ts
+type FileMetaBase = {
+  pluginName?: string;
+};
+//#endregion
+//#region src/types.d.ts
+type InputPath = {
+  /**
+   * Specify your Swagger/OpenAPI file, either as an absolute path or a path relative to the root.
+   */
+  path: string;
+};
+type InputData = {
+  /**
+   * A `string` or `object` that contains your Swagger/OpenAPI data.
+   */
+  data: string | unknown;
+};
+type Input = InputPath | InputData;
+/**
+ * The raw source passed to an adapter's `parse` function.
+ * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
+ */
+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` `InputNode`.
+ *
+ * Adapters are the single entry-point for different schema formats
+ * (OpenAPI, AsyncAPI, Drizzle, …) and produce the universal `InputNode`
+ * 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;
+  inputNode: InputNode | null;
+  /**
+   * Convert the raw source into a universal `InputNode`.
+   */
+  parse: (source: AdapterSource) => PossiblePromise<InputNode>;
+  /**
+   * Extracts `ImportNode` 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<ImportNode>;
+};
+/**
+ * Controls how `index.ts` barrel files are generated.
+ * - `'all'` — exports every generated symbol from every file.
+ * - `'named'` — exports only explicitly named exports.
+ * - `'propagate'` — propagates re-exports from nested barrel files upward.
+ */
+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;
+  /**
+   * An array of parsers used to convert generated files to strings.
+   * Each parser handles specific file extensions (e.g. `.ts`, `.tsx`).
+   *
+   * A catch-all fallback parser is always appended last for any unhandled extension.
+   *
+   * When omitted, `parserTs` from `@kubb/parser-ts` is used automatically as the
+   * default (requires `@kubb/parser-ts` to be installed as an optional dependency).
+   * @default [parserTs] — from `@kubb/parser-ts`
+   * @example
+   * ```ts
+   * import { parserTs, tsxParser } from '@kubb/parser-ts'
+   * export default defineConfig({
+   *   parsers: [parserTs, tsxParser],
+   * })
+   * ```
+   */
+  parsers: Array<Parser>;
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `InputNode` — the universal
+   * intermediate representation consumed by all Kubb plugins.
+   *
+   * - Use `@kubb/adapter-oas` for OpenAPI / Swagger.
+   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
+   *
+   * @example
+   * ```ts
+   * import { adapterOas } from '@kubb/adapter-oas'
+   * export default defineConfig({
+   *   adapter: adapterOas(),
+   *   input: { path: './petStore.yaml' },
+   * })
+   * ```
+   */
+  adapter: Adapter;
+  /**
+   * Source file or data to generate code from.
+   * Use `input.path` for a file on disk or `input.data` for an inline string or object.
+   */
+  input: TInput;
+  output: {
+    /**
+     * Output directory for generated files.
+     * Accepts an absolute path or a path relative to `root`.
+     */
+    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<FileNode['extname'], FileNode['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 used for code generation.
+   * Each plugin may declare additional configurable options.
+   * If a plugin depends on another, an error is thrown when the dependency is missing.
+   * Use `dependencies` on the plugin to declare execution order.
+   */
+  plugins: Array<Plugin>;
+  /**
+   * Project-wide renderer factory. All plugins and generators that do not declare their own
+   * `renderer` ultimately fall back to this value.
+   *
+   * The resolution chain is: `generator.renderer` → `plugin.renderer` → `config.renderer` → `undefined` (raw `FileNode[]` mode).
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * export default defineConfig({
+   *   renderer: jsxRenderer,
+   *   plugins: [pluginTs(), pluginZod()],
+   * })
+   * ```
+   */
+  renderer?: RendererFactory;
+  /**
+   * 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): string;
+  resolveFile(params: ResolverFileParams, context: ResolverContext): FileNode;
+  resolveBanner(node: InputNode | null, context: ResolveBannerContext): string | undefined;
+  resolveFooter(node: InputNode | null, context: ResolveBannerContext): string | undefined;
+};
+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;
+};
+/**
+ * @deprecated
+ */
+type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name used for the plugin.
+   * The name follows the format `scope:foo-bar` or `foo-bar` — adding a scope avoids conflicts with other plugins.
+   *
+   * @example Plugin name
+   * `'@kubb/typescript'`
+   */
+  name: TOptions['name'];
+  /**
+   * Resolved options merged with output/include/exclude/override defaults for the current plugin.
+   */
+  options: TOptions['resolvedOptions'] & {
+    output: Output;
+    include?: Array<Include>;
+    exclude: Array<Exclude$1>;
+    override: Array<Override<TOptions['resolvedOptions']>>;
+  };
+  /**
+   * The resolver for this plugin.
+   * Set via `setResolver()` in `kubb:plugin:setup` or passed as a user option.
+   */
+  resolver?: TOptions['resolver'];
+  /**
+   * The composed transformer for this plugin.
+   * Set via `setTransformer()` in `kubb:plugin:setup` or passed as a user option.
+   */
+  transformer?: Visitor;
+  /**
+   * Plugin-level renderer factory. All generators that do not declare their own `renderer`
+   * inherit this value. A generator can explicitly opt out by setting `renderer: null`.
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * createPlugin((options) => ({
+   *   name: 'my-plugin',
+   *   renderer: jsxRenderer,
+   *   generators: [
+   *     { name: 'types', schema(node) { return <File>...</File> } },   // inherits jsxRenderer
+   *     { name: 'raw', renderer: null, schema(node) { return [...] } }, // explicit opt-out
+   *   ],
+   * }))
+   * ```
+   */
+  renderer?: RendererFactory;
+  /**
+   * Generators declared directly on the plugin. Each generator's `renderer` takes precedence
+   * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
+   * when the plugin declares a renderer.
+   */
+  generators?: Array<Generator>;
+  /**
+   * Specifies the plugins that the current plugin depends on. The current plugin is executed after all listed plugins.
+   * An error is returned if any required dependency plugin is missing.
+   */
+  dependencies?: 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'];
+};
+/**
+ * @deprecated
+ */
+type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>;
+/**
+ * Partial version of {@link Config} intended for user-facing config entry points.
+ *
+ * Fields that have sensible defaults (`root`, `plugins`, `parsers`, `adapter`) are optional.
+ */
+type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'parsers' | 'adapter'> & {
+  /**
+   * 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 parsers used to convert generated files to strings.
+   * Each parser handles specific file extensions (e.g. `.ts`, `.tsx`).
+   *
+   * A catch-all fallback parser is always appended last for any unhandled extension.
+   */
+  parsers?: Array<Parser>;
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `InputNode`.
+   */
+  adapter?: Adapter;
+  /**
+   * User-facing plugins can be either legacy createPlugin instances or hook-style plugins.
+   */
+  plugins?: Array<Omit<UserPlugin, 'inject'> | HookStylePlugin>;
+};
+/**
+ * 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<unknown | Array<FileNode> | 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<unknown | Array<FileNode> | 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<unknown | Array<FileNode> | void>;
+/**
+ * @deprecated will be replaced with HookStylePlugin
+ */
+type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name used for the plugin.
+   *
+   * @example Plugin name
+   * `'@kubb/typescript'`
+   */
+  name: TOptions['name'];
+  /**
+   * Specifies the plugins that the current plugin depends on. The current plugin is executed after all listed plugins.
+   * An error is returned if any required dependency plugin is missing.
+   */
+  dependencies?: 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$1>;
+    override: Array<Override<TOptions['resolvedOptions']>>;
+  };
+  /**
+   * The resolver for this plugin.
+   * Set via `setResolver()` in `kubb:plugin:setup` or passed as a user option.
+   */
+  resolver: TOptions['resolver'];
+  /**
+   * The composed transformer for this plugin.
+   * Set via `setTransformer()` in `kubb:plugin:setup` or passed as a user option.
+   */
+  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;
+  /**
+   * Plugin-level renderer factory. All generators that do not declare their own `renderer`
+   * inherit this value. A generator can explicitly opt out by setting `renderer: null`.
+   */
+  renderer?: RendererFactory;
+  /**
+   * Generators declared directly on the plugin. Each generator's `renderer` takes precedence
+   * over `plugin.renderer`; set `renderer: null` on a generator to opt out of rendering even
+   * when the plugin declares a renderer.
+   */
+  generators?: Array<Generator>;
+  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 `FileNode`, 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 `FileNode`, 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'];
+};
+/**
+ * @deprecated
+ */
+type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>;
+/**
+ * @deprecated
+ */
+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.
+   */
+  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 (`<File>...</File>`), an array of `FileNode` 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 `FileNode` 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>;
+  /**
+   * Resolves a path from a baseName and directory.
+   * Options can also be included.
+   *
+   * @example
+   * `('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'`
+   *
+   * @deprecated Use resolvers instead.
+   */
+  resolvePath?: (this: PluginContext<TOptions>, baseName: FileNode['baseName'], mode?: 'single' | 'split', options?: TOptions['resolvePathOptions']) => string;
+  /**
+   * Resolves a display name from a raw string.
+   * Useful when converting to PascalCase or camelCase.
+   *
+   * @example
+   * `('pet') => 'Pet'`
+   *
+   * @deprecated Use resolvers instead.
+   */
+  resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+};
+/**
+ * @deprecated
+ */
+type PluginLifecycleHooks = keyof PluginLifecycle;
+type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
+type ResolvePathParams<TOptions = object> = {
+  pluginName?: string;
+  baseName: FileNode['baseName'];
+  mode?: 'single' | 'split';
+  /**
+   * Options passed as the third argument to `resolvePath`.
+   */
+  options?: TOptions;
+};
+type ResolveNameParams = {
+  name: string;
+  pluginName?: string;
+  /**
+   * Specifies the type of entity being named.
+   * - `'file'` — customizes the name of the created file (camelCase).
+   * - `'function'` — customizes the exported function names (camelCase).
+   * - `'type'` — customizes TypeScript type names (PascalCase).
+   * - `'const'` — customizes variable names (camelCase).
+   */
+  type?: 'file' | 'function' | 'type' | 'const';
+};
+/**
+ * @deprecated
+ */
+type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+  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 `PluginDriver.getMode(path.resolve(this.root, output.path))`.
+   */
+  getMode: (output: {
+    path: string;
+  }) => 'single' | 'split';
+  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;
+  /**
+   * Add files only when they do not exist yet.
+   */
+  addFile: (...file: Array<FileNode>) => Promise<void>;
+  /**
+   * Merge multiple sources into the same output file.
+   */
+  upsertFile: (...file: Array<FileNode>) => Promise<void>;
+  hooks: AsyncEventEmitter<KubbHooks>;
+  /**
+   * The 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.hooks.emit('kubb:warn', message)`.
+   */
+  warn: (message: string) => void;
+  /**
+   * Emit an error via the build event system.
+   * Shorthand for `this.hooks.emit('kubb:error', error)`.
+   */
+  error: (error: string | Error) => void;
+  /**
+   * Emit an info message via the build event system.
+   * Shorthand for `this.hooks.emit('kubb:info', message)`.
+   */
+  info: (message: string) => void;
+  /**
+   * Opens the Kubb Studio URL for the current `inputNode` in the default browser.
+   * Falls back to printing the URL if the browser cannot be launched.
+   * No-ops silently when no adapter has set an `inputNode`.
+   */
+  openInStudio: (options?: DevtoolsOptions) => Promise<void>;
+} & ({
+  /**
+   * Returns the universal `@kubb/ast` `InputNode` produced by the configured adapter.
+   * Returns `undefined` when no adapter was set (legacy OAS-only usage).
+   */
+  inputNode: InputNode;
+  /**
+   * The adapter from `@kubb/ast`.
+   */
+  adapter: Adapter;
+} | {
+  inputNode?: never;
+  adapter?: never;
+}) & Kubb.PluginContext;
+/**
+ * Context object passed as the second argument to generator `schema`, `operation`, and
+ * `operations` methods.
+ *
+ * Generators are only invoked from `runPluginAstHooks`, which already guards against a
+ * missing adapter. This type reflects that guarantee — `ctx.adapter` and `ctx.inputNode`
+ * are always defined, so no runtime checks or casts are needed inside generator bodies.
+ *
+ * `ctx.options` carries the per-node resolved options for `schema`/`operation` calls
+ * (after exclude/include/override filtering) and the plugin-level options for `operations`.
+ */
+type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Omit<PluginContext<TOptions>, 'adapter' | 'inputNode'> & {
+  adapter: Adapter;
+  inputNode: InputNode;
+  options: TOptions['resolvedOptions'];
+};
+/**
+ * Configure generated file output location and behavior.
+ */
+type Output<_TOptions = unknown> = {
+  /**
+   * Path to the output folder or file that will contain 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;
+  /**
+   * Text or function appended at the start of every generated file.
+   * When a function, receives the current `InputNode` and must return a string.
+   */
+  banner?: string | ((node?: InputNode) => string);
+  /**
+   * Text or function appended at the end of every generated file.
+   * When a function, receives the current `InputNode` and must return a string.
+   */
+  footer?: string | ((node?: InputNode) => string);
+  /**
+   * Whether to override existing external files if they already exist.
+   * @default false
+   */
+  override?: boolean;
+};
+type UserGroup = {
+  /**
+   * Determines how files are grouped into subdirectories.
+   * - `'tag'` groups files by OpenAPI tags.
+   * - `'path'` groups files by OpenAPI paths.
+   */
+  type: 'tag' | 'path';
+  /**
+   * Returns the subdirectory name for a given group value.
+   * Defaults to `${camelCase(group)}Controller` for tags and the first path segment for paths.
+   */
+  name?: (context: {
+    group: string;
+  }) => string;
+};
+type Group = {
+  /**
+   * Determines how files are grouped into subdirectories.
+   * - `'tag'` groups files by OpenAPI tags.
+   * - `'path'` groups files by OpenAPI paths.
+   */
+  type: 'tag' | 'path';
+  /**
+   * Returns the subdirectory name for a given group value.
+   */
+  name: (context: {
+    group: string;
+  }) => string;
+};
+type LoggerOptions = {
+  /**
+   * @default 3
+   */
+  logLevel: (typeof logLevel)[keyof typeof logLevel];
+};
+/**
+ * Shared context passed to all plugins, parsers, and other internals.
+ */
+type LoggerContext = AsyncEventEmitter<KubbHooks>;
+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';
+/**
+ * Context passed to a hook-style plugin's `kubb:plugin:setup` handler.
+ * Provides methods to register generators, configure the resolver, transformer,
+ * and renderer, as well as access to the current build configuration.
+ */
+type KubbPluginSetupContext<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Register a generator on this plugin. Generators are invoked during the AST walk
+   * (schema/operation/operations) exactly like generators declared statically on `createPlugin`.
+   */
+  addGenerator<TElement = unknown>(generator: Generator<TFactory, TElement>): void;
+  /**
+   * Set or partially override the resolver for this plugin.
+   * The resolver controls file naming and path resolution for generated files.
+   *
+   * When `TFactory` is a concrete `PluginFactoryOptions` (e.g. `PluginClient`),
+   * the resolver parameter is typed to the plugin's own resolver type (e.g. `ResolverClient`).
+   */
+  setResolver(resolver: Partial<TFactory['resolver']>): void;
+  /**
+   * Set the AST transformer (visitor) for this plugin.
+   * The transformer pre-processes nodes before they reach the generators.
+   */
+  setTransformer(visitor: Visitor): void;
+  /**
+   * Set the renderer factory for this plugin.
+   * Used to process JSX elements returned by generators.
+   */
+  setRenderer(renderer: RendererFactory): void;
+  /**
+   * Set the resolved options for the build loop. These options are merged into the
+   * normalized plugin's `options` object (which includes `output`, `exclude`, `override`).
+   *
+   * Call this in `kubb:plugin:setup` to provide the resolved options that generators
+   * and the build loop need (e.g., `enumType`, `optionalType`, `group`).
+   */
+  setOptions(options: TFactory['resolvedOptions']): void;
+  /**
+   * Inject a raw file into the build output, bypassing the normal generation pipeline.
+   */
+  injectFile(file: Pick<FileNode, 'baseName' | 'path'> & {
+    sources?: FileNode['sources'];
+  }): void;
+  /**
+   * Merge a partial config update into the current build configuration.
+   */
+  updateConfig(config: Partial<Config>): void;
+  /**
+   * The resolved build configuration at the time of setup.
+   */
+  config: Config;
+  /**
+   * The plugin's own options as passed by the user.
+   */
+  options: TFactory['options'];
+};
+/**
+ * Context passed to a hook-style plugin's `kubb:build:start` handler.
+ * Fires immediately before the plugin execution loop begins.
+ */
+type KubbBuildStartContext = {
+  config: Config;
+  adapter: Adapter;
+  inputNode: InputNode;
+  getPlugin(name: string): Plugin | undefined;
+};
+/**
+ * Context passed to a hook-style plugin's `kubb:build:end` handler.
+ * Fires after all files have been written to disk.
+ */
+type KubbBuildEndContext = {
+  files: Array<FileNode>;
+  config: Config;
+  outputDir: string;
+};
+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;
+};
+/**
+ * A pattern filter that prevents matching nodes from being generated.
+ * Match by `tag`, `operationId`, `path`, `method`, `contentType`, or `schemaName`.
+ */
+type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+/**
+ * A pattern filter that restricts generation to only matching nodes.
+ * Match by `tag`, `operationId`, `path`, `method`, `contentType`, or `schemaName`.
+ */
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+/**
+ * A pattern filter paired with partial option overrides applied when the pattern matches.
+ * Match by `tag`, `operationId`, `path`, `method`, `schemaName`, or `contentType`.
+ */
+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: FileNode['baseName'];
+  pathMode?: 'single' | 'split';
+  /**
+   * 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: FileNode['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(inputNode, { output: { banner: '// generated' }, config })
+ * // → '// generated'
+ * ```
+ */
+type ResolveBannerContext = {
+  output?: Pick<Output, 'banner' | 'footer'>;
+  config: Config;
+};
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
+  /**
+   * Path to `kubb.config.js`.
+   */
+  config?: string;
+  /**
+   * Enable watch mode for input files.
+   */
+  watch?: boolean;
+  /**
+   * Logging verbosity for CLI usage.
+   * @default 'silent'
+   */
+  logLevel?: 'silent' | 'info' | 'debug';
+};
+/**
+ * All accepted forms of a Kubb configuration.
+ *
+ * Config is always `@kubb/core` {@link Config}.
+ * - `PossibleConfig` accepts `Config`/`Config[]`/promise or a no-arg config factory.
+ * - `PossibleConfig<TCliOptions>` accepts the same config forms or a config factory receiving `TCliOptions`.
+ */
+type PossibleConfig<TCliOptions = undefined> = PossiblePromise<Config | Config[]> | ((...args: [TCliOptions] extends [undefined] ? [] : [TCliOptions]) => PossiblePromise<Config | Config[]>);
+//#endregion
+export { KubbHooks as $, PluginParameter as A, ResolverFileParams as B, Output as C, PluginFactoryOptions as D, PluginContext as E, ResolveOptionsContext as F, UserLogger as G, SchemaHook as H, ResolvePathOptions as I, FileMetaBase as J, UserPlugin as K, ResolvePathParams as L, PossibleConfig as M, ResolveBannerContext as N, PluginLifecycle as O, ResolveNameParams as P, Kubb$1 as Q, Resolver as R, OperationsHook as S, Plugin as T, UserConfig as U, ResolverPathParams as V, UserGroup as W, PluginHooks as X, HookStylePlugin as Y, definePlugin as Z, KubbPluginSetupContext as _, CLIOptions as a, defineParser as at, LoggerOptions as b, DevtoolsOptions as c, Storage as ct, Group as d, RendererFactory as dt, BuildOutput as et, Include as f, createRenderer as ft, KubbBuildStartContext as g, KubbBuildEndContext as h, BarrelType as i, Parser as it, PluginWithLifeCycle as j, PluginLifecycleHooks as k, Exclude$1 as l, createStorage as lt, InputPath as m, AsyncEventEmitter as mt, AdapterFactoryOptions as n, PluginDriver as nt, CompatibilityPreset as o, Generator as ot, InputData as p, logLevel as pt, UserPluginWithLifeCycle as q, AdapterSource as r, FileManager as rt, Config as s, defineGenerator as st, Adapter as t, createKubb as tt, GeneratorContext as u, Renderer as ut, Logger as v, Override as w, OperationHook as x, LoggerContext as y, ResolverContext as z };
+//# sourceMappingURL=types-C6NCtNqM.d.ts.map