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

package/dist/index.d.ts

@@ -1,162 +1,301 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import { A as UserPluginWithLifeCycle, B as formatters, C as PrinterFactoryOptions, D as UserConfig, E as UnknownUserPlugin, F as KubbEvents, H as logLevel, I as PluginManager, L as getMode, M as Generator, N as ReactGeneratorV2, O as UserLogger, P as defineGenerator, R as DefineStorage, S as Printer, T as ResolvePathParams, U as AsyncEventEmitter, V as linters, W as URLPath, _ 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 CoreGeneratorV2, 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 defineStorage } from "./types-Bbh1o0yW.js";
-import { definePrinter } from "@kubb/ast";
-import { Fabric } from "@kubb/react-fabric";
-import { Node } from "@kubb/ast/types";
-import { KubbFile } from "@kubb/fabric-core/types";
+import { $ as KubbHooks, A as PluginParameter, B as ResolverFileParams, C as Output, D as PluginFactoryOptions, E as PluginContext, F as ResolveOptionsContext, G as UserLogger, H as SchemaHook, I as ResolvePathOptions, J as FileMetaBase, K as UserPlugin, L as ResolvePathParams, M as PossibleConfig, N as ResolveBannerContext, O as PluginLifecycle, P as ResolveNameParams, Q as Kubb, R as Resolver, S as OperationsHook, T as Plugin, U as UserConfig, V as ResolverPathParams, W as UserGroup, X as PluginHooks, Y as HookStylePlugin, Z as definePlugin, _ as KubbPluginSetupContext, a as CLIOptions, at as defineParser, b as LoggerOptions, c as DevtoolsOptions, ct as Storage, d as Group, dt as RendererFactory, et as BuildOutput, f as Include, ft as createRenderer, g as KubbBuildStartContext, h as KubbBuildEndContext, i as BarrelType, it as Parser, j as PluginWithLifeCycle, k as PluginLifecycleHooks, l as Exclude, lt as createStorage, m as InputPath, mt as AsyncEventEmitter, n as AdapterFactoryOptions, nt as PluginDriver, o as CompatibilityPreset, ot as Generator, p as InputData, pt as logLevel, q as UserPluginWithLifeCycle, r as AdapterSource, rt as FileManager, s as Config, st as defineGenerator, t as Adapter, tt as createKubb, u as GeneratorContext, ut as Renderer, v as Logger, w as Override, x as OperationHook, y as LoggerContext, z as ResolverContext } from "./types-C6NCtNqM.js";
+import * as ast from "@kubb/ast";
+import { FileNode, InputNode, Node } from "@kubb/ast";
 
-//#region src/build.d.ts
-type BuildOptions = {
-  config: UserConfig;
-  events?: AsyncEventEmitter<KubbEvents>;
-};
-type BuildOutput = {
-  failedPlugins: Set<{
-    plugin: Plugin;
-    error: Error;
-  }>;
-  fabric: Fabric;
-  files: Array<KubbFile.ResolvedFile>;
-  pluginManager: PluginManager;
-  pluginTimings: Map<string, number>;
-  error?: Error;
-  sources: Map<KubbFile.Path, string>;
+//#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 SetupResult = {
-  events: AsyncEventEmitter<KubbEvents>;
-  fabric: Fabric;
-  pluginManager: PluginManager;
-  sources: Map<KubbFile.Path, 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;
 };
-declare function setup(options: BuildOptions): Promise<SetupResult>;
-declare function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
-declare function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
-//#endregion
-//#region src/config.d.ts
 /**
- * CLI options derived from command-line flags.
+ * Supported identifier casing strategies for path parameters.
  */
-type CLIOptions = {
-  /** Path to `kubb.config.js` */config?: string; /** Enable watch mode for input files */
-  watch?: boolean;
+type PathCasing = 'camelcase';
+type Options = {
   /**
-   * 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'
+   * Casing strategy applied to path parameter names.
+   * @default undefined (original identifier preserved)
    */
-  logLevel?: 'silent' | 'info' | 'debug'; /** Run Kubb with Bun */
-  bun?: boolean;
+  casing?: PathCasing;
 };
-/** All accepted forms of a Kubb configuration. */
-type ConfigInput = PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>);
 /**
- * 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
+ * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
  *
  * @example
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
- * }))
+ * const p = new URLPath('/pet/{petId}')
+ * p.URL      // '/pet/:petId'
+ * p.template // '`/pet/${petId}`'
  */
-declare function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config;
-declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config;
+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/createAdapter.d.ts
 /**
- * Type guard to check if a given config has an `input.path`.
+ * Builder type for an {@link Adapter} — takes options and returns the adapter 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>;
 /**
- * Wraps an adapter builder to make the options parameter optional.
+ * Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
  *
  * @example
- * ```ts
- * export const adapterOas = defineAdapter<OasAdapter>((options) => {
- *   const { validate = true, dateType = 'string' } = options
+ * export const myAdapter = createAdapter<MyAdapter>((options) => {
  *   return {
- *     name: adapterOasName,
- *     options: { validate, dateType, ... },
- *     parse(source) { ... },
+ *     name: 'my-adapter',
+ *     options,
+ *     async parse(source) { ... },
  *   }
  * })
- * ```
+ *
+ * // instantiate
+ * const adapter = myAdapter({ validate: true })
  */
-declare function defineAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
 //#endregion
 //#region src/defineLogger.d.ts
-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>;
 /**
- * Wraps a plugin builder to make the options parameter optional.
+ * Wraps a logger definition into a typed {@link Logger}.
+ *
+ * @example
+ * export const myLogger = defineLogger({
+ *   name: 'my-logger',
+ *   install(context, options) {
+ *     context.on('kubb:info', (message) => console.log('ℹ', message))
+ *     context.on('kubb:error', (error) => console.error('✗', error.message))
+ *   },
+ * })
  */
-declare function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(build: PluginBuilder<T>): (options?: T['options']) => UserPluginWithLifeCycle<T>;
-//#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;
-}
+declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
 //#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>>>[]>;
 /**
- * Runs an array of promise functions with optional concurrency limit.
+ * 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 `FileNode` 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')
+ *   },
+ * }))
+ * ```
  */
-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;
+declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
 //#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;
+//#region src/FileProcessor.d.ts
+type ParseOptions = {
+  parsers?: Map<FileNode['extname'], Parser>;
+  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
+};
+type RunOptions = ParseOptions & {
+  /**
+   * @default 'sequential'
+   */
+  mode?: 'sequential' | 'parallel';
+  onStart?: (files: Array<FileNode>) => Promise<void> | void;
+  onEnd?: (files: Array<FileNode>) => Promise<void> | void;
+  onUpdate?: (params: {
+    file: FileNode;
+    source?: string;
+    processed: number;
+    total: number;
+    percentage: number;
+  }) => Promise<void> | void;
 };
-declare class PromiseManager<TState = unknown> {
+/**
+ * Converts a single file to a string using the registered parsers.
+ * Falls back to joining source values when no matching parser is found.
+ */
+declare class FileProcessor {
   #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;
+  parse(file: FileNode, {
+    parsers,
+    extension
+  }?: ParseOptions): Promise<string>;
+  run(files: Array<FileNode>, {
+    parsers,
+    mode,
+    extension,
+    onStart,
+    onEnd,
+    onUpdate
+  }?: RunOptions): Promise<Array<FileNode>>;
 }
 //#endregion
 //#region src/storages/fsStorage.d.ts
@@ -183,7 +322,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
 /**
@@ -203,149 +342,14 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Define
  * })
  * ```
  */
-declare const memoryStorage: (options?: Record<string, never> | undefined) => DefineStorage;
+declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#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;
+//#region src/utils/isInputPath.d.ts
 /**
- * @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;
-}
-//#endregion
-//#region src/utils/formatters.d.ts
-type Formatter = keyof typeof formatters;
-/**
- * Detect which formatter is available in the 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.
- *
- * @example
- * ```typescript
- * const formatter = await detectFormatter()
- * if (formatter) {
- *   console.log(`Using ${formatter} for formatting`)
- * } else {
- *   console.log('No formatter found')
- * }
- * ```
- */
-declare function detectFormatter(): Promise<Formatter | undefined>;
-//#endregion
-//#region src/utils/getBarrelFiles.d.ts
-type FileMetaBase = {
-  pluginName?: string;
-};
-type AddIndexesProps = {
-  type: BarrelType | false | undefined;
-  /**
-   * Root based on root and output.path specified in the config
-   */
-  root: string;
-  /**
-   * Output for plugin
-   */
-  output: {
-    path: string;
-  };
-  group?: {
-    output: string;
-    exportAs: string;
-  };
-  meta?: FileMetaBase;
-};
-declare function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, {
-  type,
-  meta,
-  root,
-  output
-}: AddIndexesProps): Promise<KubbFile.File[]>;
-//#endregion
-//#region src/utils/getConfigs.d.ts
-/**
- * Converting UserConfig to Config Array without a change in the object beside the JSON convert.
- */
-declare function getConfigs(config: ConfigInput | UserConfig, args: CLIOptions): Promise<Array<Config>>;
-//#endregion
-//#region src/utils/linters.d.ts
-type Linter = keyof typeof linters;
-declare function detectLinter(): Promise<Linter | undefined>;
-//#endregion
-//#region src/utils/resolveOptions.d.ts
-type FilterItem = {
-  type: string;
-  pattern: string | RegExp;
-};
-type OverrideItem<TOptions> = FilterItem & {
-  options: Partial<TOptions>;
-};
-type ResolveOptionsContext<TOptions> = {
-  options: TOptions;
-  exclude?: Array<FilterItem>;
-  include?: Array<FilterItem>;
-  override?: Array<OverrideItem<TOptions>>;
-};
-/**
- * Resolves the effective plugin options for a given AST node by applying
- * `exclude`, `include`, and `override` rules from the plugin configuration.
- *
- * Returns `null` when the node is excluded or not matched by `include`.
- * Returns the merged options (base options merged with any matching `override`) otherwise.
- *
- * Supported filter types for `OperationNode`: `tag`, `operationId`, `path`, `method`.
- * Supported filter types for `SchemaNode`: `schemaName`.
- *
- * @example
- * const resolved = resolveOptions(operationNode, { options, exclude, include, override })
- * if (!resolved) return // excluded
+ * Type guard to check if a given config has an `input.path`.
  */
-declare function resolveOptions<TOptions>(node: Node, {
-  options,
-  exclude,
-  include,
-  override
-}: ResolveOptionsContext<TOptions>): TOptions | null;
+declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath>;
+declare function isInputPath(config: Config | undefined): config is Config<InputPath>;
 //#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, type CLIOptions, Config, type ConfigInput, CoreGeneratorV2, DefineStorage, DevtoolsOptions, type FileMetaBase, FunctionParams, type FunctionParamsAST, Generator, GetPluginFactoryOptions, Group, InputData, InputPath, KubbEvents, Logger, LoggerContext, LoggerOptions, Output, PackageManager, Plugin, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginWithLifeCycle, Printer, PrinterFactoryOptions, PromiseManager, ReactGeneratorV2, ResolveNameParams, ResolvePathParams, URLPath, UnknownUserPlugin, UserConfig, UserLogger, UserPlugin, UserPluginWithLifeCycle, build, build as default, defineAdapter, defineConfig, defineGenerator, defineLogger, definePlugin, definePrinter, defineStorage, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, resolveOptions, safeBuild, setup };
+export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BarrelType, BuildOutput, CLIOptions, CompatibilityPreset, Config, DevtoolsOptions, Exclude, FileManager, FileMetaBase, FileProcessor, Generator, GeneratorContext, Group, HookStylePlugin, Include, InputData, InputPath, Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbHooks, KubbPluginSetupContext, Logger, LoggerContext, LoggerOptions, OperationHook, OperationsHook, Output, Override, Parser, Plugin, PluginContext, PluginDriver, PluginFactoryOptions, PluginHooks, PluginLifecycle, PluginLifecycleHooks, PluginParameter, PluginWithLifeCycle, PossibleConfig, Renderer, RendererFactory, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, ResolvePathOptions, ResolvePathParams, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, SchemaHook, Storage, URLPath, UserConfig, UserGroup, UserLogger, UserPlugin, UserPluginWithLifeCycle, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map