@kubb/core 4.5.0 → 4.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "4.5.0",
+  "version": "4.5.2",
   "description": "Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.",
   "keywords": [
     "typescript",
@@ -83,7 +83,7 @@
     }
   ],
   "dependencies": {
-    "@kubb/react-fabric": "0.2.14",
+    "@kubb/react-fabric": "0.2.19",
     "camelcase": "^8.0.0",
     "find-up": "^7.0.0",
     "fs-extra": "^11.3.2",
@@ -106,10 +106,10 @@
     "zod": "^4.1.12"
   },
   "optionalDependencies": {
-    "@kubb/fabric-core": "0.2.14"
+    "@kubb/fabric-core": "0.2.19"
   },
   "peerDependencies": {
-    "@kubb/react-fabric": "0.2.14"
+    "@kubb/react-fabric": "0.2.19"
   },
   "engines": {
     "node": ">=20"

package/src/BarrelManager.ts

@@ -1,9 +1,9 @@
 /** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
 import type { KubbFile } from '@kubb/fabric-core/types'
-import type { FileMetaBase } from './FileManager.ts'
 import { getRelativePath } from './fs/index.ts'
 import type { Logger } from './logger.ts'
+import type { FileMetaBase } from './utils/getBarrelFiles.ts'
 import { TreeNode } from './utils/TreeNode.ts'
 
 type BarrelManagerOptions = {

package/src/PluginManager.ts

@@ -1,16 +1,16 @@
+import path from 'node:path'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Fabric } from '@kubb/react-fabric'
 import { ValidationPluginError } from './errors.ts'
 import type { Logger } from './logger.ts'
 import { isPromiseRejectedResult, PromiseManager } from './PromiseManager.ts'
-import type { PluginCore } from './plugin.ts'
-import { pluginCore } from './plugin.ts'
 import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { trim } from './transformers/trim.ts'
 import type {
   Config,
   GetPluginFactoryOptions,
   Plugin,
+  PluginContext,
   PluginFactoryOptions,
   PluginLifecycle,
   PluginLifecycleHooks,
@@ -19,7 +19,6 @@ import type {
   ResolveNameParams,
   ResolvePathParams,
   UserPlugin,
-  UserPluginWithLifeCycle,
 } from './types.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
 import { setUniqueName } from './utils/uniqueName.ts'
@@ -69,8 +68,14 @@ type GetFileProps<TOptions = object> = {
   options?: TOptions
 }
 
+export function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode {
+  if (!fileOrFolder) {
+    return 'split'
+  }
+  return path.extname(fileOrFolder) ? 'single' : 'split'
+}
+
 export class PluginManager {
-  readonly plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
   readonly events: EventEmitter<Events> = new EventEmitter()
 
   readonly config: Config
@@ -78,8 +83,8 @@ export class PluginManager {
   readonly executed: Array<Executer> = []
   readonly logger: Logger
   readonly options: Options
-  readonly #core: Plugin<PluginCore>
 
+  readonly #plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager: PromiseManager
 
@@ -91,27 +96,51 @@ export class PluginManager {
       nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
     })
 
-    const core = pluginCore({
-      fabric: options.fabric,
-      config,
-      logger: this.logger,
-      pluginManager: this,
-      resolvePath: this.resolvePath.bind(this),
-      resolveName: this.resolveName.bind(this),
-      getPlugins: this.#getSortedPlugins.bind(this),
-    })
+    ;[...(config.plugins || [])].forEach((plugin) => {
+      const parsedPlugin = this.#parse(plugin as UserPlugin)
 
-    // call core.context.call with empty context so we can transform `context()` to `context: {}`
-    this.#core = this.#parse(core as unknown as UserPlugin, this as any, core.context.call(null as any)) as Plugin<PluginCore>
-    ;[this.#core, ...(config.plugins || [])].forEach((plugin) => {
-      const parsedPlugin = this.#parse(plugin as UserPlugin, this, this.#core.context)
-
-      this.plugins.add(parsedPlugin)
+      this.#plugins.add(parsedPlugin)
     })
 
     return this
   }
 
+  getContext<TOptions extends PluginFactoryOptions>(plugin: Plugin<TOptions>): PluginContext<TOptions> & Record<string, any> {
+    const plugins = [...this.#plugins]
+    const baseContext = {
+      fabric: this.options.fabric,
+      config: this.config,
+      plugin,
+      logger: this.options.logger,
+      pluginManager: this,
+      mode: getMode(path.resolve(this.config.root, this.config.output.path)),
+      addFile: async (...files: Array<KubbFile.File>) => {
+        await this.options.fabric.addFile(...files)
+      },
+    } as unknown as PluginContext<TOptions>
+
+    let mergedExtras: Record<string, any> = {}
+    for (const p of plugins) {
+      if (typeof p.inject === 'function') {
+        const injector = p.inject.bind(baseContext as any) as any
+
+        const result = injector(baseContext)
+        if (result && typeof result === 'object') {
+          mergedExtras = { ...mergedExtras, ...result }
+        }
+      }
+    }
+
+    return {
+      ...baseContext,
+      ...mergedExtras,
+    }
+  }
+
+  get plugins(): Array<Plugin> {
+    return this.#getSortedPlugins()
+  }
+
   getFile<TOptions = object>({ name, mode, extname, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
     const baseName = `${name}${extname}` as const
     const path = this.resolvePath({ baseName, mode, pluginKey, options })
@@ -130,7 +159,10 @@ export class PluginManager {
     }
   }
 
-  resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): KubbFile.OptionalPath => {
+  resolvePath = <TOptions = object>(params: ResolvePathParams<TOptions>): KubbFile.Path => {
+    const root = path.resolve(this.config.root, this.config.output.path)
+    const defaultPath = path.resolve(root, params.baseName)
+
     if (params.pluginKey) {
       const paths = this.hookForPluginSync({
         pluginKey: params.pluginKey,
@@ -150,13 +182,16 @@ export class PluginManager {
         })
       }
 
-      return paths?.at(0)
+      return paths?.at(0) || defaultPath
     }
-    return this.hookFirstSync({
+
+    const firstResult = this.hookFirstSync({
       hookName: 'resolvePath',
       parameters: [params.baseName, params.mode, params.options as object],
       message: `Resolving path '${params.baseName}'`,
-    }).result
+    })
+
+    return firstResult?.result || defaultPath
   }
   //TODO refactor by using the order of plugins and the cache of the fileManager instead of guessing and recreating the name/path
   resolveName = (params: ResolveNameParams): string => {
@@ -423,8 +458,8 @@ export class PluginManager {
     this.logger.emit('progress_stop', { id: hookName })
   }
 
-  #getSortedPlugins(hookName?: keyof PluginLifecycle): Plugin[] {
-    const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
+  #getSortedPlugins(hookName?: keyof PluginLifecycle): Array<Plugin> {
+    const plugins = [...this.#plugins]
 
     if (hookName) {
       return plugins.filter((plugin) => hookName in plugin)
@@ -434,10 +469,10 @@ export class PluginManager {
     return plugins
       .map((plugin) => {
         if (plugin.pre) {
-          const isValid = plugin.pre.every((pluginName) => plugins.find((pluginToFind) => pluginToFind.name === pluginName))
+          const missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName))
 
-          if (!isValid) {
-            throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, undefined, 2)})`)
+          if (missingPlugins.length > 0) {
+            throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(', ')}'`)
           }
         }
 
@@ -455,7 +490,7 @@ export class PluginManager {
   }
 
   getPluginByKey(pluginKey: Plugin['key']): Plugin | undefined {
-    const plugins = [...this.plugins]
+    const plugins = [...this.#plugins]
     const [searchPluginName] = pluginKey
 
     return plugins.find((item) => {
@@ -547,7 +582,8 @@ export class PluginManager {
     const task = (async () => {
       try {
         if (typeof hook === 'function') {
-          const result = await Promise.resolve((hook as Function).apply({ ...this.#core.context, plugin }, parameters))
+          const context = this.getContext(plugin)
+          const result = await Promise.resolve((hook as Function).apply(context, parameters))
 
           output = result
 
@@ -615,7 +651,8 @@ export class PluginManager {
 
     try {
       if (typeof hook === 'function') {
-        const fn = (hook as Function).apply({ ...this.#core.context, plugin }, parameters) as ReturnType<ParseResult<H>>
+        const context = this.getContext(plugin)
+        const fn = (hook as Function).apply(context, parameters) as ReturnType<ParseResult<H>>
 
         output = fn
 
@@ -657,54 +694,15 @@ export class PluginManager {
     this.events.emit('error', cause)
   }
 
-  #parse<TPlugin extends UserPluginWithLifeCycle>(
-    plugin: TPlugin,
-    pluginManager: PluginManager,
-    context: PluginCore['context'] | undefined,
-  ): Plugin<GetPluginFactoryOptions<TPlugin>> {
-    const usedPluginNames = pluginManager.#usedPluginNames
+  #parse(plugin: UserPlugin): Plugin {
+    const usedPluginNames = this.#usedPluginNames
 
     setUniqueName(plugin.name, usedPluginNames)
 
-    const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.name, string]
-
-    if (plugin.context && typeof plugin.context === 'function') {
-      return {
-        ...plugin,
-        key,
-        context: (plugin.context as Function).call(context) as typeof plugin.context,
-      } as unknown as Plugin<GetPluginFactoryOptions<TPlugin>>
-    }
-
     return {
+      install() {},
       ...plugin,
-      key,
-    } as unknown as Plugin<GetPluginFactoryOptions<TPlugin>>
-  }
-
-  static getDependedPlugins<
-    T1 extends PluginFactoryOptions,
-    T2 extends PluginFactoryOptions = never,
-    T3 extends PluginFactoryOptions = never,
-    TOutput = T3 extends never ? (T2 extends never ? [T1: Plugin<T1>] : [T1: Plugin<T1>, T2: Plugin<T2>]) : [T1: Plugin<T1>, T2: Plugin<T2>, T3: Plugin<T3>],
-  >(plugins: Array<Plugin>, dependedPluginNames: string | string[]): TOutput {
-    let pluginNames: string[] = []
-    if (typeof dependedPluginNames === 'string') {
-      pluginNames = [dependedPluginNames]
-    } else {
-      pluginNames = dependedPluginNames
-    }
-
-    return pluginNames.map((pluginName) => {
-      const plugin = plugins.find((plugin) => plugin.name === pluginName)
-      if (!plugin) {
-        throw new ValidationPluginError(`This plugin depends on the ${pluginName} plugin.`)
-      }
-      return plugin
-    }) as TOutput
-  }
-
-  static get hooks() {
-    return ['buildStart', 'resolvePath', 'resolveName', 'buildEnd'] as const
+      key: [plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.name, string],
+    } as unknown as Plugin
   }
 }

package/src/build.ts

@@ -11,7 +11,7 @@ import { clean, exists, getRelativePath, write } from './fs/index.ts'
 import type { Logger } from './logger.ts'
 import { createLogger } from './logger.ts'
 import { PluginManager } from './PluginManager.ts'
-import type { Config, Output, UserConfig } from './types.ts'
+import type { Config, Output, Plugin, UserConfig } from './types.ts'
 import { URLPath } from './utils/URLPath.ts'
 
 type BuildOptions = {
@@ -23,11 +23,14 @@ type BuildOptions = {
 }
 
 type BuildOutput = {
+  failedPlugins: Set<{ plugin: Plugin; error: Error }>
   fabric: Fabric
   files: Array<KubbFile.ResolvedFile>
   pluginManager: PluginManager
+  // TODO check if we can remove error
   /**
-   * Only for safeBuild
+   * Only for safeBuild,
+   * @deprecated
    */
   error?: Error
 }
@@ -92,13 +95,14 @@ export async function setup(options: BuildOptions): Promise<SetupResult> {
 }
 
 export async function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, files, pluginManager, error } = await safeBuild(options, overrides)
+  const { fabric, files, pluginManager, failedPlugins, error } = await safeBuild(options, overrides)
 
   if (error) {
     throw error
   }
 
   return {
+    failedPlugins,
     fabric,
     files,
     pluginManager,
@@ -109,14 +113,21 @@ export async function build(options: BuildOptions, overrides?: SetupResult): Pro
 export async function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
   const { fabric, pluginManager } = overrides ? overrides : await setup(options)
 
+  const failedPlugins = new Set<{ plugin: Plugin; error: Error }>()
   const config = pluginManager.config
 
   try {
-    await pluginManager.hookParallel({
-      hookName: 'buildStart',
-      parameters: [config],
-      message: 'buildStart',
-    })
+    for (const plugin of pluginManager.plugins) {
+      const context = pluginManager.getContext(plugin)
+
+      const installer = plugin.install.bind(context)
+
+      try {
+        await installer(context)
+      } catch (e) {
+        failedPlugins.add({ plugin, error: e as Error })
+      }
+    }
 
     if (config.output.barrelType) {
       const root = resolve(config.root)
@@ -166,11 +177,11 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
       await fabric.addFile(rootFile)
     }
 
-    fabric.context.events.on('process:start', ({ files }) => {
+    fabric.context.on('process:start', ({ files }) => {
       pluginManager.logger.emit('progress_start', { id: 'files', size: files.length, message: 'Writing files ...' })
     })
 
-    fabric.context.events.on('process:progress', async ({ file, source }) => {
+    fabric.context.on('process:progress', async ({ file, source }) => {
       const message = file ? `Writing ${relative(config.root, file.path)}` : ''
       pluginManager.logger.emit('progressed', { id: 'files', message })
 
@@ -179,22 +190,22 @@ export async function safeBuild(options: BuildOptions, overrides?: SetupResult):
       }
     })
 
-    fabric.context.events.on('process:end', () => {
+    fabric.context.on('process:end', () => {
       pluginManager.logger.emit('progress_stop', { id: 'files' })
     })
     const files = [...fabric.files]
 
     await fabric.write({ extension: config.output.extension })
 
-    await pluginManager.hookParallel({ hookName: 'buildEnd', message: `Build stopped for ${config.name}` })
-
     return {
+      failedPlugins,
       fabric,
       files,
       pluginManager,
     }
   } catch (e) {
     return {
+      failedPlugins,
       fabric,
       files: [],
       pluginManager,

package/src/config.ts

@@ -1,47 +1,53 @@
 import type { InputPath, UserConfig } from './types.ts'
 import type { PossiblePromise } from './utils/types.ts'
 
-type Args = {
-  /**
-   * Path to `kubb.config.js`
-   */
+/**
+ * CLI options derived from command-line flags.
+ */
+export type CLIOptions = {
+  /** Path to `kubb.config.js` */
   config?: string
-  /**
-   * Watch changes on input
-   */
+
+  /** Enable watch mode for input files */
   watch?: boolean
 
   /**
-   * Log level to report when using the CLI
+   * Logging verbosity for CLI usage.
    *
-   * `silent` will hide all information that is not relevant
-   *
-   * `info` will show all information possible(not related to the PluginManager)
-   *
-   * `debug` will show all information possible(related to the PluginManager), handy for seeing logs
-   * @default `silent`
-   */
-  logLevel?: string
-  /**
-   * Run Kubb with Bun
+   * - `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
 }
 
 /**
- * Type helper to make it easier to use vite.config.ts accepts a direct UserConfig object, or a function that returns it. The function receives a ConfigEnv object.
+ * 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
+ *
+ * @example
+ * export default defineConfig(({ logLevel }) => ({
+ *   root: 'src',
+ *   plugins: [myPlugin()],
+ * }))
  */
 export function defineConfig(
-  options:
-    | PossiblePromise<UserConfig | Array<UserConfig>>
-    | ((
-        /** The options derived from the CLI flags */
-        args: Args,
-      ) => PossiblePromise<UserConfig | Array<UserConfig>>),
-): typeof options {
-  return options
+  config: PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>),
+): typeof config {
+  return config
 }
 
-export function isInputPath(result: UserConfig | undefined): result is UserConfig<InputPath> {
-  return !!result && 'path' in (result?.input as any)
+/**
+ * Type guard to check if a given config has an `input.path`.
+ */
+export function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> {
+  return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
 }

package/src/definePlugin.ts

@@ -0,0 +1,12 @@
+import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
+
+type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
+
+/**
+ * Wraps a plugin builder to make the options parameter optional.
+ */
+export function definePlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
+  build: PluginBuilder<T>,
+): (options?: T['options']) => UserPluginWithLifeCycle<T> {
+  return (options) => build(options ?? ({} as T['options']))
+}

package/src/index.ts

@@ -1,10 +1,10 @@
 export { BaseGenerator } from './BaseGenerator.ts'
 export { build, build as default, safeBuild, setup } from './build.ts'
-export { defineConfig, isInputPath } from './config.ts'
-export type { FileMetaBase } from './FileManager.ts'
-export { getBarrelFiles, getMode } from './FileManager.ts'
+export { type CLIOptions, defineConfig, isInputPath } from './config.ts'
+export { definePlugin } from './definePlugin.ts'
 export { PackageManager } from './PackageManager.ts'
-export { PluginManager } from './PluginManager.ts'
+export { getMode, PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
-export { createPlugin } from './plugin.ts'
 export type * from './types.ts'
+export type { FileMetaBase } from './utils/getBarrelFiles.ts'
+export { getBarrelFiles } from './utils/getBarrelFiles.ts'

package/src/types.ts

@@ -1,9 +1,15 @@
 import type { KubbFile } from '@kubb/fabric-core/types'
-import type { Fabric, FileManager } from '@kubb/react-fabric'
+import type { Fabric } from '@kubb/react-fabric'
 import type { Logger } from './logger.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { PossiblePromise } from './utils/types.ts'
 
+declare global {
+  namespace Kubb {
+    interface PluginContext {}
+  }
+}
+
 /**
  * Config used in `kubb.config.ts`
  *
@@ -191,13 +197,8 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
    * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
    */
   post?: Array<string>
-} & (TOptions['context'] extends never
-  ? {
-      context?: never
-    }
-  : {
-      context: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['context']
-    })
+  inject?: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context']
+}
 
 export type UserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = UserPlugin<TOptions> & PluginLifecycle<TOptions>
 
@@ -227,16 +228,13 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
   options: TOptions['resolvedOptions']
+
+  install: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>
   /**
-   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `createPlugin`).
+   * Define a context that can be used by other plugins, see `PluginManager' where we convert from `UserPlugin` to `Plugin`(used when calling `definePlugin`).
    */
-} & (TOptions['context'] extends never
-  ? {
-      context?: never
-    }
-  : {
-      context: TOptions['context']
-    })
+  inject: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => TOptions['context']
+}
 
 export type PluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = Plugin<TOptions> & PluginLifecycle<TOptions>
 
@@ -245,19 +243,14 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * Start of the lifecycle of a plugin.
    * @type hookParallel
    */
-  buildStart?: (this: PluginContext<TOptions>, Config: Config) => PossiblePromise<void>
+  install?: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>
   /**
    * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
    * Options can als be included.
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (
-    this: PluginContext<TOptions>,
-    baseName: KubbFile.BaseName,
-    mode?: KubbFile.Mode,
-    options?: TOptions['resolvePathOptions'],
-  ) => KubbFile.OptionalPath
+  resolvePath?: (this: PluginContext<TOptions>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.Path
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -265,11 +258,6 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * @example ('pet') => 'Pet'
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-  /**
-   * End of the plugin lifecycle.
-   * @type hookParallel
-   */
-  buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>
 }
 
 export type PluginLifecycleHooks = keyof PluginLifecycle
@@ -301,24 +289,15 @@ export type ResolveNameParams = {
 export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   fabric: Fabric
   config: Config
-  /**
-   * @deprecated
-   */
-  fileManager: FileManager
   pluginManager: PluginManager
-  addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>
-  resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath
-  resolveName: (params: ResolveNameParams) => string
+  addFile: (...file: Array<KubbFile.File>) => Promise<void>
   logger: Logger
-  /**
-   * All plugins
-   */
-  plugins: Plugin[]
+  mode: KubbFile.Mode
   /**
    * Current plugin
    */
   plugin: Plugin<TOptions>
-}
+} & Kubb.PluginContext
 /**
  * Specify the export location for the files and define the behavior of the output
  */