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

package/dist/index.d.ts

@@ -1,162 +1,544 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as UserPluginWithLifeCycle, B as URLPath, C as PrinterFactoryOptions, D as UserConfig, E as UnknownUserPlugin, F as defineStorage, I as formatters, L as linters, M as PluginManager, N as getMode, O as UserLogger, P as DefineStorage, R as logLevel, S as Printer, T as ResolvePathParams, _ as PluginFactoryOptions, a as Config, b as PluginParameter, c as Group, d as Logger, f as LoggerContext, g as PluginContext, h as Plugin, i as BarrelType, j as KubbEvents, k as UserPlugin, l as InputData, m as Output, n as AdapterFactoryOptions, o as DevtoolsOptions, p as LoggerOptions, r as AdapterSource, s as GetPluginFactoryOptions, t as Adapter, u as InputPath, v as PluginLifecycle, w as ResolveNameParams, x as PluginWithLifeCycle, y as PluginLifecycleHooks, z as AsyncEventEmitter } from "./types-CiPWLv-5.js";
-import { definePrinter } from "@kubb/ast";
-import { Fabric } from "@kubb/react-fabric";
-import { KubbFile } from "@kubb/fabric-core/types";
+import { n as __name } from "./chunk-O_arW02_.js";
+import { $ as FunctionParams, A as Preset, B as Resolver, C as Plugin, D as PluginLifecycleHooks, E as PluginLifecycle, F as ResolveBannerContext, G as UserConfig, H as ResolverFileParams, I as ResolveNameParams, J as UserPlugin, K as UserGroup, L as ResolveOptionsContext, M as Printer, N as PrinterFactoryOptions, O as PluginParameter, P as PrinterPartial, Q as getBarrelFiles, R as ResolvePathOptions, S as Override, T as PluginFactoryOptions, U as ResolverPathParams, V as ResolverContext, W as SchemaHook, X as UserResolver, Y as UserPluginWithLifeCycle, Z as FileMetaBase, _ as LoggerContext, _t as KubbFile_d_exports, a as AdapterSource, at as Parser, b as OperationsHook, bt as ResolvedFile, c as Config, ct as Generator, d as GeneratorContext, dt as Storage, et as FunctionParamsAST, f as Group, ft as createStorage, g as Logger, gt as File, h as InputPath, ht as logLevel, i as AdapterFactoryOptions, it as KubbEvents, j as Presets, k as PluginWithLifeCycle, l as DevtoolsOptions, lt as defineGenerator, m as InputData, mt as linters, n as getMode, nt as ConfigInput, o as BarrelType, ot as UserParser, p as Include, pt as formatters, q as UserLogger, r as Adapter, rt as defineConfig, s as CompatibilityPreset, st as defineParser, t as PluginDriver, tt as CLIOptions, u as Exclude, ut as mergeGenerators, v as LoggerOptions, w as PluginContext, x as Output, xt as AsyncEventEmitter, y as OperationHook, yt as Path, z as ResolvePathParams } from "./PluginDriver-D0dY_hpJ.js";
+import { composeTransformers, definePrinter } from "@kubb/ast";
+import { Node, RootNode, Visitor } from "@kubb/ast/types";
+import { Fabric } from "@kubb/fabric-core/types";
 
+//#region ../../internals/utils/src/urlPath.d.ts
+type URLObject = {
+  /**
+   * The resolved URL string (Express-style or template literal, depending on context).
+   */
+  url: string;
+  /**
+   * Extracted path parameters as a key-value map, or `undefined` when the path has none.
+   */
+  params?: Record<string, string>;
+};
+type ObjectOptions = {
+  /**
+   * Controls whether the `url` is rendered as an Express path or a template literal.
+   * @default 'path'
+   */
+  type?: 'path' | 'template';
+  /**
+   * Optional transform applied to each extracted parameter name.
+   */
+  replacer?: (pathParam: string) => string;
+  /**
+   * When `true`, the result is serialized to a string expression instead of a plain object.
+   */
+  stringify?: boolean;
+};
+/**
+ * Supported identifier casing strategies for path parameters.
+ */
+type PathCasing = 'camelcase';
+type Options = {
+  /**
+   * Casing strategy applied to path parameter names.
+   * @default undefined (original identifier preserved)
+   */
+  casing?: PathCasing;
+};
+/**
+ * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+ *
+ * @example
+ * const p = new URLPath('/pet/{petId}')
+ * p.URL      // '/pet/:petId'
+ * p.template // '`/pet/${petId}`'
+ */
+declare class URLPath {
+  #private;
+  /**
+   * The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+   */
+  path: string;
+  constructor(path: string, options?: Options);
+  /** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+   *
+   * @example
+   * ```ts
+   * new URLPath('/pet/{petId}').URL // '/pet/:petId'
+   * ```
+   */
+  get URL(): string;
+  /** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+   *
+   * @example
+   * ```ts
+   * new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+   * new URLPath('/pet/{petId}').isURL                       // false
+   * ```
+   */
+  get isURL(): boolean;
+  /**
+   * Converts the OpenAPI path to a TypeScript template literal string.
+   *
+   * @example
+   * new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+   * new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+   */
+  get template(): string;
+  /** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+   *
+   * @example
+   * ```ts
+   * new URLPath('/pet/{petId}').object
+   * // { url: '/pet/:petId', params: { petId: 'petId' } }
+   * ```
+   */
+  get object(): URLObject | string;
+  /** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+   *
+   * @example
+   * ```ts
+   * new URLPath('/pet/{petId}').params // { petId: 'petId' }
+   * new URLPath('/pet').params         // undefined
+   * ```
+   */
+  get params(): Record<string, string> | undefined;
+  toObject({
+    type,
+    replacer,
+    stringify
+  }?: ObjectOptions): URLObject | string;
+  /**
+   * Converts the OpenAPI path to a TypeScript template literal string.
+   * An optional `replacer` can transform each extracted parameter name before interpolation.
+   *
+   * @example
+   * new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+   */
+  toTemplateString({
+    prefix,
+    replacer
+  }?: {
+    prefix?: string;
+    replacer?: (pathParam: string) => string;
+  }): string;
+  /**
+   * Extracts all `{param}` segments from the path and returns them as a key-value map.
+   * An optional `replacer` transforms each parameter name in both key and value positions.
+   * Returns `undefined` when no path parameters are found.
+   *
+   * @example
+   * ```ts
+   * new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+   * // { petId: 'petId', tagId: 'tagId' }
+   * ```
+   */
+  getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined;
+  /** Converts the OpenAPI path to Express-style colon syntax.
+   *
+   * @example
+   * ```ts
+   * new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+   * ```
+   */
+  toURLPath(): string;
+}
+//#endregion
 //#region src/build.d.ts
 type BuildOptions = {
   config: UserConfig;
   events?: AsyncEventEmitter<KubbEvents>;
 };
+/**
+ * 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;
   }>;
   fabric: Fabric;
-  files: Array<KubbFile.ResolvedFile>;
-  pluginManager: PluginManager;
+  files: Array<ResolvedFile>;
+  driver: PluginDriver;
+  /**
+   * Elapsed time in milliseconds for each plugin, keyed by plugin name.
+   */
   pluginTimings: Map<string, number>;
   error?: Error;
-  sources: Map<KubbFile.Path, string>;
+  /**
+   * Raw generated source, keyed by absolute file path.
+   */
+  sources: Map<Path, string>;
 };
+/**
+ * Intermediate result returned by {@link setup} and accepted by {@link safeBuild}.
+ */
 type SetupResult = {
   events: AsyncEventEmitter<KubbEvents>;
   fabric: Fabric;
-  pluginManager: PluginManager;
-  sources: Map<KubbFile.Path, string>;
+  driver: PluginDriver;
+  sources: Map<Path, string>;
+  config: Config;
 };
+/**
+ * Initializes all Kubb infrastructure for a build without executing any plugins.
+ *
+ * - Validates the input path (when applicable).
+ * - Applies config defaults (`root`, `output.*`, `devtools`).
+ * - Creates the Fabric instance and wires storage, format, and lint hooks.
+ * - Runs the adapter (if configured) to produce the universal `RootNode`.
+ *   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
+ *
+ * Pass the returned {@link SetupResult} directly to {@link safeBuild} or {@link build}
+ * via the `overrides` argument to reuse the same infrastructure across multiple runs.
+ */
 declare function setup(options: BuildOptions): Promise<SetupResult>;
+/**
+ * Runs a full Kubb build and throws on any error or plugin failure.
+ *
+ * Internally delegates to {@link safeBuild} and rethrows collected errors.
+ * Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
+ */
 declare function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
+/**
+ * Runs a full Kubb build and captures errors instead of throwing.
+ *
+ * - Installs each plugin in order, recording failures in `failedPlugins`.
+ * - Generates the root barrel file when `output.barrelType` is set.
+ * - Writes all files through Fabric.
+ *
+ * Returns a {@link BuildOutput} even on failure — inspect `error` and
+ * `failedPlugins` to determine whether the build succeeded.
+ */
 declare function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
 //#endregion
-//#region src/config.d.ts
+//#region src/createAdapter.d.ts
 /**
- * CLI options derived from command-line flags.
+ * Builder type for an {@link Adapter} — takes options and returns the adapter instance.
  */
-type CLIOptions = {
-  /** Path to `kubb.config.js` */config?: string; /** Enable watch mode for input files */
-  watch?: boolean;
-  /**
-   * Logging verbosity for CLI usage.
-   *
-   * - `silent`: hide non-essential logs
-   * - `info`: show general logs (non-plugin-related)
-   * - `debug`: include detailed plugin lifecycle logs
-   * @default 'silent'
-   */
-  logLevel?: 'silent' | 'info' | 'debug'; /** Run Kubb with Bun */
-  bun?: boolean;
-};
-/** All accepted forms of a Kubb configuration. */
-type ConfigInput = PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>);
+type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
 /**
- * Helper for defining a Kubb configuration.
- *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
+ * Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
  *
  * @example
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
- * }))
+ * export const myAdapter = createAdapter<MyAdapter>((options) => {
+ *   return {
+ *     name: 'my-adapter',
+ *     options,
+ *     async parse(source) { ... },
+ *   }
+ * })
+ *
+ * // instantiate
+ * const adapter = myAdapter({ validate: true })
  */
-declare function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config;
-declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config;
+declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+//#endregion
+//#region src/createPlugin.d.ts
 /**
- * Type guard to check if a given config has an `input.path`.
+ * Builder type for a {@link UserPluginWithLifeCycle} — takes options and returns the plugin instance.
  */
-declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
-//#endregion
-//#region src/defineAdapter.d.ts
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
+type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>;
 /**
- * Wraps an adapter builder to make the options parameter optional.
+ * Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
  *
  * @example
  * ```ts
- * export const adapterOas = defineAdapter<OasAdapter>((options) => {
- *   const { validate = true, dateType = 'string' } = options
+ * export const myPlugin = createPlugin<MyPlugin>((options) => {
  *   return {
- *     name: adapterOasName,
- *     options: { validate, dateType, ... },
- *     parse(source) { ... },
+ *     name: 'my-plugin',
+ *     get options() { return options },
+ *     resolvePath(baseName) { ... },
+ *     resolveName(name, type) { ... },
  *   }
  * })
+ *
+ * // instantiate
+ * const plugin = myPlugin({ output: { path: 'src/gen' } })
  * ```
  */
-declare function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
 //#endregion
 //#region src/defineLogger.d.ts
+/**
+ * Wraps a logger definition into a typed {@link Logger}.
+ *
+ * @example
+ * export const myLogger = defineLogger({
+ *   name: 'my-logger',
+ *   install(context, options) {
+ *     context.on('info', (message) => console.log('ℹ', message))
+ *     context.on('error', (error) => console.error('✗', error.message))
+ *   },
+ * })
+ */
 declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
 //#endregion
-//#region src/definePlugin.d.ts
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>;
+//#region src/definePresets.d.ts
 /**
- * Wraps a plugin builder to make the options parameter optional.
+ * Creates a typed presets registry object — a named collection of {@link Preset} entries.
+ *
+ * @example
+ * import { definePreset, definePresets } from '@kubb/core'
+ * import { resolverTsLegacy } from '@kubb/plugin-ts'
+ *
+ * export const myPresets = definePresets({
+ *   kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy] }),
+ * })
  */
-declare function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
+declare function definePresets<TResolver extends Resolver = Resolver>(presets: Presets<TResolver>): Presets<TResolver>;
 //#endregion
-//#region src/PackageManager.d.ts
-type PackageJSON = {
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-};
-type DependencyName = string;
-type DependencyVersion = string;
-declare class PackageManager {
-  #private;
-  constructor(workspace?: string);
-  set workspace(workspace: string);
-  get workspace(): string | undefined;
-  normalizeDirectory(directory: string): string;
-  getLocation(path: string): string;
-  import(path: string): Promise<unknown>;
-  getPackageJSON(): Promise<PackageJSON | undefined>;
-  getPackageJSONSync(): PackageJSON | undefined;
-  static setVersion(dependency: DependencyName, version: DependencyVersion): void;
-  getVersion(dependency: DependencyName | RegExp): Promise<DependencyVersion | undefined>;
-  getVersionSync(dependency: DependencyName | RegExp): DependencyVersion | undefined;
-  isValid(dependency: DependencyName | RegExp, version: DependencyVersion): Promise<boolean>;
-  isValidSync(dependency: DependencyName | RegExp, version: DependencyVersion): boolean;
-}
-//#endregion
-//#region src/utils/executeStrategies.d.ts
-type PromiseFunc$1<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2;
-type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc$1<infer X, infer Y>> ? X | Y : never;
-type SeqOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>;
+//#region src/defineResolver.d.ts
 /**
- * Chains promises
+ * Builder type for the plugin-specific resolver fields.
+ *
+ * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
+ * are optional — built-in fallbacks are injected when omitted.
  */
-type HookFirstOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>;
+type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'> & Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
+  name: string;
+  pluginName: T['name'];
+} & ThisType<T['resolver']>;
 /**
- * Chains promises, first non-null result stops and returns
+ * Default option resolver — applies include/exclude filters and merges matching override options.
+ *
+ * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+ *
+ * @example Include/exclude filtering
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { output: 'types' },
+ *   exclude: [{ type: 'tag', pattern: 'internal' }],
+ * })
+ * // → null when node has tag 'internal'
+ * ```
+ *
+ * @example Override merging
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { enumType: 'asConst' },
+ *   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
+ * })
+ * // → { enumType: 'enum' } when operationId matches
+ * ```
  */
-type HookParallelOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>;
+declare function defaultResolveOptions<TOptions>(node: Node, {
+  options,
+  exclude,
+  include,
+  override
+}: ResolveOptionsContext<TOptions>): TOptions | null;
 /**
- * Runs an array of promise functions with optional concurrency limit.
+ * Default path resolver used by `defineResolver`.
+ *
+ * - Returns the output directory in `single` mode.
+ * - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+ * - Falls back to a flat `output/baseName` path otherwise.
+ *
+ * A custom `group.name` function overrides the default subdirectory naming.
+ * For `tag` groups the default is `${camelCase(tag)}Controller`.
+ * For `path` groups the default is the first path segment after `/`.
+ *
+ * @example Flat output
+ * ```ts
+ * defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+ * // → '/src/types/petTypes.ts'
+ * ```
+ *
+ * @example Tag-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → '/src/types/petsController/petTypes.ts'
+ * ```
+ *
+ * @example Path-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', path: '/pets/list' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+ * )
+ * // → '/src/types/pets/petTypes.ts'
+ * ```
+ *
+ * @example Single-file mode
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', pathMode: 'single' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → '/src/types'
+ * ```
  */
-type Strategy = 'seq' | 'first' | 'parallel';
-type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = TStrategy extends 'first' ? HookFirstOutput<TInput, TValue> : TStrategy extends 'seq' ? SeqOutput<TInput, TValue> : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue> : never;
-//#endregion
-//#region src/PromiseManager.d.ts
-type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
-type Options<TState = unknown> = {
-  nullCheck?: (state: TState) => boolean;
-};
-declare class PromiseManager<TState = unknown> {
-  #private;
-  constructor(options?: Options<TState>);
-  run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(strategy: TStrategy, promises: TInput, {
-    concurrency
-  }?: {
-    concurrency?: number;
-  }): TOutput;
-}
+declare function defaultResolvePath({
+  baseName,
+  pathMode,
+  tag,
+  path: groupPath
+}: ResolverPathParams, {
+  root,
+  output,
+  group
+}: ResolverContext): Path;
+/**
+ * Default file resolver used by `defineResolver`.
+ *
+ * Resolves a `KubbFile.File` by combining name resolution (`resolver.default`) with
+ * path resolution (`resolver.resolvePath`). The resolved file always has empty
+ * `sources`, `imports`, and `exports` arrays — consumers populate those separately.
+ *
+ * In `single` mode the name is omitted and the file sits directly in the output directory.
+ *
+ * @example Resolve a schema file
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'pet', extname: '.ts' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+ * ```
+ *
+ * @example Resolve an operation file with tag grouping
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'listPets', extname: '.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+ * ```
+ */
+declare function defaultResolveFile(this: Resolver, {
+  name,
+  extname,
+  tag,
+  path: groupPath
+}: ResolverFileParams, context: ResolverContext): File;
+/**
+ * Generates the default "Generated by Kubb" banner from config and optional node metadata.
+ */
+declare function buildDefaultBanner({
+  title,
+  description,
+  version,
+  config
+}: {
+  title?: string;
+  description?: string;
+  version?: string;
+  config: Config;
+}): string;
+/**
+ * Default banner resolver — returns the banner string for a generated file.
+ *
+ * A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
+ * When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
+ * from the OAS spec when a `node` is provided).
+ *
+ * - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
+ * - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+ * - When `output.banner` is a string, returns it directly.
+ * - When `config.output.defaultBanner` is `false`, returns `undefined`.
+ * - Otherwise returns the Kubb "Generated by Kubb" notice.
+ *
+ * @example String banner overrides default
+ * ```ts
+ * defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+ * // → '// my banner'
+ * ```
+ *
+ * @example Function banner with node
+ * ```ts
+ * defaultResolveBanner(rootNode, { output: { banner: (node) => `// v${node.version}` }, config })
+ * // → '// v3.0.0'
+ * ```
+ *
+ * @example No user banner — Kubb notice with OAS metadata
+ * ```ts
+ * defaultResolveBanner(rootNode, { config })
+ * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
+ * ```
+ *
+ * @example Disabled default banner
+ * ```ts
+ * defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+ * // → undefined
+ * ```
+ */
+declare function defaultResolveBanner(node: RootNode | undefined, {
+  output,
+  config
+}: ResolveBannerContext): string | undefined;
+/**
+ * Default footer resolver — returns the footer string for a generated file.
+ *
+ * - When `output.footer` is a function and `node` is provided, calls it with the node.
+ * - When `output.footer` is a function and `node` is absent, returns `undefined`.
+ * - When `output.footer` is a string, returns it directly.
+ * - Otherwise returns `undefined`.
+ *
+ * @example String footer
+ * ```ts
+ * defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+ * // → '// end of file'
+ * ```
+ *
+ * @example Function footer with node
+ * ```ts
+ * defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+ * // → '// Pet Store'
+ * ```
+ */
+declare function defaultResolveFooter(node: RootNode | undefined, {
+  output
+}: ResolveBannerContext): string | undefined;
+/**
+ * Defines a resolver for a plugin, injecting built-in defaults for name casing,
+ * include/exclude/override filtering, path resolution, and file construction.
+ *
+ * All four defaults can be overridden by providing them in the builder function:
+ * - `default` — name casing strategy (camelCase / PascalCase)
+ * - `resolveOptions` — include/exclude/override filtering
+ * - `resolvePath` — output path computation
+ * - `resolveFile` — full `KubbFile.File` construction
+ *
+ * Methods in the builder have access to `this` (the full resolver object), so they
+ * can call other resolver methods without circular imports.
+ *
+ * @example Basic resolver with naming helpers
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
+ *   resolveName(node) {
+ *     return this.default(node.name, 'function')
+ *   },
+ *   resolveTypedName(node) {
+ *     return this.default(node.name, 'type')
+ *   },
+ * }))
+ * ```
+ *
+ * @example Override resolvePath for a custom output structure
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'custom',
+ *   resolvePath({ baseName }, { root, output }) {
+ *     return path.resolve(root, output.path, 'generated', baseName)
+ *   },
+ * }))
+ * ```
+ *
+ * @example Use this.default inside a helper
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
+ *   resolveParamName(node, param) {
+ *     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+ *   },
+ * }))
+ * ```
+ */
+declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
 //#endregion
 //#region src/storages/fsStorage.d.ts
 /**
@@ -182,7 +564,7 @@ declare class PromiseManager<TState = unknown> {
  * })
  * ```
  */
-declare const fsStorage: (options?: Record<string, never> | undefined) => DefineStorage;
+declare const fsStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
 //#region src/storages/memoryStorage.d.ts
 /**
@@ -202,114 +584,113 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Define
  * })
  * ```
  */
-declare const memoryStorage: (options?: Record<string, never> | undefined) => DefineStorage;
-//#endregion
-//#region src/utils/FunctionParams.d.ts
-type FunctionParamsASTWithoutType = {
-  name?: string;
-  type?: string;
-  /**
-   * @default true
-   */
-  required?: boolean;
-  /**
-   * @default true
-   */
-  enabled?: boolean;
-  default?: string;
-};
-type FunctionParamsASTWithType = {
-  name?: never;
-  type: string;
-  /**
-   * @default true
-   */
-  required?: boolean;
-  /**
-   * @default true
-   */
-  enabled?: boolean;
-  default?: string;
-};
-/**
- * @deprecated
- */
-type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
-/**
- * @deprecated
- */
-declare class FunctionParams {
-  #private;
-  get items(): FunctionParamsAST[];
-  add(item: FunctionParamsAST | Array<FunctionParamsAST | FunctionParamsAST[] | undefined> | undefined): FunctionParams;
-  static toObject(items: FunctionParamsAST[]): FunctionParamsAST;
-  toObject(): FunctionParamsAST;
-  static toString(items: (FunctionParamsAST | FunctionParamsAST[])[]): string;
-  toString(): string;
-}
+declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
 //#region src/utils/formatters.d.ts
 type Formatter = keyof typeof formatters;
 /**
- * Detect which formatter is available in the system.
+ * Detects the first available code formatter on the current system.
  *
- * @returns Promise that resolves to the first available formatter or undefined if none are found
- *
- * @remarks
- * Checks in order of preference: biome, oxfmt, prettier.
- * Uses the `--version` flag to detect if each formatter command is available.
- * This is a reliable method as all supported formatters implement this flag.
+ * - Checks in preference order: `biome`, `oxfmt`, `prettier`.
+ * - Returns `null` when none are found.
  *
  * @example
- * ```typescript
+ * ```ts
  * const formatter = await detectFormatter()
  * if (formatter) {
  *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
  * }
  * ```
  */
-declare function detectFormatter(): Promise<Formatter | undefined>;
+declare function detectFormatter(): Promise<Formatter | null>;
 //#endregion
-//#region src/utils/getBarrelFiles.d.ts
-type FileMetaBase = {
-  pluginName?: string;
-};
-type AddIndexesProps = {
-  type: BarrelType | false | undefined;
+//#region src/utils/getConfigs.d.ts
+/**
+ * Resolves a {@link ConfigInput} into a normalized array of {@link Config} objects.
+ *
+ * - Awaits the config when it is a `Promise`.
+ * - Calls the factory function with `args` when the config is a function.
+ * - Wraps a single config object in an array for uniform downstream handling.
+ */
+declare function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>>;
+//#endregion
+//#region src/utils/getPreset.d.ts
+type GetPresetParams<TResolver extends Resolver> = {
+  preset: CompatibilityPreset;
+  presets: Presets<TResolver>;
   /**
-   * Root based on root and output.path specified in the config
+   * Optional single resolver whose methods override the preset resolver.
+   * When a method returns `null` or `undefined` the preset resolver's method is used instead.
    */
-  root: string;
+  resolver?: Partial<TResolver> & ThisType<TResolver>;
   /**
-   * Output for plugin
+   * User-supplied generators to append after the preset's generators.
    */
-  output: {
-    path: string;
-  };
-  group?: {
-    output: string;
-    exportAs: string;
-  };
-  meta?: FileMetaBase;
+  generators?: Array<Generator<any>>;
+  /**
+   * Optional single transformer visitor whose methods override the preset transformer.
+   * When a method returns `null` or `undefined` the preset transformer's method is used instead.
+   */
+  transformer?: Visitor;
 };
-declare function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, {
-  type,
-  meta,
-  root,
-  output
-}: AddIndexesProps): Promise<KubbFile.File[]>;
+type GetPresetResult<TResolver extends Resolver> = {
+  resolver: TResolver;
+  transformer: Visitor | undefined;
+  generators: Array<Generator<any>>;
+  preset: Preset<TResolver> | undefined;
+};
+/**
+ * Resolves a named preset into a resolver, transformer, and generators.
+ *
+ * - Selects the preset resolver; wraps it with user overrides using null/undefined fallback.
+ * - Composes the preset's transformers into a single visitor; wraps it with the user transformer using null/undefined fallback.
+ * - Combines preset generators with user-supplied generators; falls back to the `default` preset's generators when neither provides any.
+ */
+declare function getPreset<TResolver extends Resolver = Resolver>(params: GetPresetParams<TResolver>): GetPresetResult<TResolver>;
 //#endregion
-//#region src/utils/getConfigs.d.ts
+//#region src/utils/isInputPath.d.ts
 /**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+ * Type guard to check if a given config has an `input.path`.
  */
-declare function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>>;
+declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
 //#endregion
 //#region src/utils/linters.d.ts
 type Linter = keyof typeof linters;
-declare function detectLinter(): Promise<Linter | undefined>;
+/**
+ * Detects the first available linter on the current system.
+ *
+ * - Checks in preference order: `biome`, `oxlint`, `eslint`.
+ * - Returns `null` when none are found.
+ *
+ * @example
+ * ```ts
+ * const linter = await detectLinter()
+ * if (linter) {
+ *   console.log(`Using ${linter} for linting`)
+ * }
+ * ```
+ */
+declare function detectLinter(): Promise<Linter | null>;
+//#endregion
+//#region src/utils/packageJSON.d.ts
+type DependencyName = string;
+type DependencyVersion = string;
+/**
+ * Returns `true` when the nearest `package.json` declares a dependency that
+ * satisfies the given semver range.
+ *
+ * - Searches both `dependencies` and `devDependencies`.
+ * - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
+ * - Uses `semver.satisfies` for range comparison; returns `false` when the
+ *   version string cannot be coerced into a valid semver.
+ *
+ * @example
+ * ```ts
+ * satisfiesDependency('react', '>=18')          // true when react@18.x is installed
+ * satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
+ * ```
+ */
+declare function satisfiesDependency(dependency: DependencyName | RegExp, version: DependencyVersion, cwd?: string): boolean;
 //#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, type CLIOptions, Config, type ConfigInput, DefineStorage, DevtoolsOptions, type FileMetaBase, FunctionParams, type FunctionParamsAST, GetPluginFactoryOptions, Group, InputData, InputPath, KubbEvents, Logger, LoggerContext, LoggerOptions, Output, PackageManager, Plugin, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, Printer, PrinterFactoryOptions, PromiseManager, ResolveNameParams, ResolvePathParams, URLPath, UnknownUserPlugin, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, build, build as default, defineAdapter, defineConfig, defineLogger, definePlugin, definePrinter, defineStorage, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, setup };
+export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, CLIOptions, CompatibilityPreset, Config, ConfigInput, DevtoolsOptions, Exclude, FileMetaBase, FunctionParams, FunctionParamsAST, Generator, GeneratorContext, Group, Include, InputData, InputPath, KubbEvents, KubbFile_d_exports as KubbFile, Logger, LoggerContext, LoggerOptions, OperationHook, OperationsHook, Output, Override, Parser, Plugin, PluginContext, PluginDriver, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginParameter, PluginWithLifeCycle, Preset, Presets, Printer, PrinterFactoryOptions, PrinterPartial, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, ResolvePathOptions, ResolvePathParams, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, SchemaHook, Storage, URLPath, UserConfig, UserGroup, UserLogger, UserParser, UserPlugin, UserPluginWithLifeCycle, UserResolver, build, build as default, buildDefaultBanner, composeTransformers, createAdapter, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineConfig, defineGenerator, defineLogger, defineParser, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeGenerators, safeBuild, satisfiesDependency, setup };
 //# sourceMappingURL=index.d.ts.map