@kubb/core 5.0.0-alpha.21 → 5.0.0-alpha.23

package/src/defineGenerator.ts

@@ -1,6 +1,7 @@
 import type { OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import type { FabricReactNode } from '@kubb/react-fabric/types'
+import type { PluginDriver } from './PluginDriver.ts'
 import type { Adapter, Config, Plugin, PluginFactoryOptions } from './types.ts'
 
 export type Version = '1' | '2'
@@ -12,7 +13,9 @@ export type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFacto
   config: Config
   plugin: Plugin<TPlugin>
   adapter: Adapter
+  driver: PluginDriver
   options: Plugin<TPlugin>['options']
+  resolver: TPlugin['resolver']
   nodes: Array<OperationNode>
 }
 
@@ -22,8 +25,10 @@ export type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFacto
 export type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
+  driver: PluginDriver
   plugin: Plugin<TPlugin>
   options: Plugin<TPlugin>['options']
+  resolver: TPlugin['resolver']
   node: OperationNode
 }
 
@@ -33,20 +38,28 @@ export type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactor
 export type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
+  driver: PluginDriver
   plugin: Plugin<TPlugin>
   options: Plugin<TPlugin>['options']
+  resolver: TPlugin['resolver']
   node: SchemaNode
 }
 
+/**
+ * Input shape for a core v2 async generator — lifecycle methods are optional.
+ */
 type UserCoreGeneratorV2<TPlugin extends PluginFactoryOptions> = {
   name: string
   type: 'core'
   version?: '2'
-  operations?(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  operation?(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  schema?(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>
+  operations?(props: OperationsV2Props<TPlugin>): Promise<Array<FabricFile.File>>
+  operation?(props: OperationV2Props<TPlugin>): Promise<Array<FabricFile.File>>
+  schema?(props: SchemaV2Props<TPlugin>): Promise<Array<FabricFile.File>>
 }
 
+/**
+ * Input shape for a React v2 generator — component methods are optional.
+ */
 type UserReactGeneratorV2<TPlugin extends PluginFactoryOptions> = {
   name: string
   type: 'react'
@@ -56,15 +69,21 @@ type UserReactGeneratorV2<TPlugin extends PluginFactoryOptions> = {
   Schema?(props: SchemaV2Props<TPlugin>): FabricReactNode
 }
 
+/**
+ * A fully resolved core v2 generator with `version: '2'` and guaranteed async lifecycle methods.
+ */
 export type CoreGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   name: string
   type: 'core'
   version: '2'
-  operations(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  operation(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  schema(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>
+  operations(props: OperationsV2Props<TPlugin>): Promise<Array<FabricFile.File>>
+  operation(props: OperationV2Props<TPlugin>): Promise<Array<FabricFile.File>>
+  schema(props: SchemaV2Props<TPlugin>): Promise<Array<FabricFile.File>>
 }
 
+/**
+ * A fully resolved React v2 generator with `version: '2'` and guaranteed component methods.
+ */
 export type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
   name: string
   type: 'react'
@@ -74,6 +93,9 @@ export type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactor
   Schema(props: SchemaV2Props<TPlugin>): FabricReactNode
 }
 
+/**
+ * Union of all v2 generator shapes accepted by the plugin system.
+ */
 export type Generator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>
 
 /**

package/src/defineResolver.ts

@@ -2,7 +2,7 @@ import path from 'node:path'
 import { camelCase, pascalCase } from '@internals/utils'
 import { isOperationNode, isSchemaNode } from '@kubb/ast'
 import type { Node, OperationNode, RootNode, SchemaNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import { getMode } from './PluginDriver.ts'
 import type {
   Config,
@@ -193,33 +193,27 @@ export function defaultResolveOptions<TOptions>(
  * // → '/src/types'
  * ```
  */
-export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): KubbFile.Path {
+export function defaultResolvePath(
+  { baseName, pathMode, tag, path: groupPath }: ResolverPathParams,
+  { root, output, group }: ResolverContext,
+): FabricFile.Path {
   const mode = pathMode ?? getMode(path.resolve(root, output.path))
 
   if (mode === 'single') {
-    return path.resolve(root, output.path) as KubbFile.Path
+    return path.resolve(root, output.path) as FabricFile.Path
   }
 
   if (group && (groupPath || tag)) {
-    const groupName = group.name
-      ? group.name
-      : (ctx: { group: string }) => {
-          if (group.type === 'path') {
-            return `${ctx.group.split('/')[1]}`
-          }
-          return `${camelCase(ctx.group)}Controller`
-        }
-
-    return path.resolve(root, output.path, groupName({ group: group.type === 'path' ? groupPath! : tag! }), baseName) as KubbFile.Path
+    return path.resolve(root, output.path, group.name({ group: group.type === 'path' ? groupPath! : tag! }), baseName) as FabricFile.Path
   }
 
-  return path.resolve(root, output.path, baseName) as KubbFile.Path
+  return path.resolve(root, output.path, baseName) as FabricFile.Path
 }
 
 /**
  * Default file resolver used by `defineResolver`.
  *
- * Resolves a `KubbFile.File` by combining name resolution (`resolver.default`) with
+ * Resolves a `FabricFile.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.
  *
@@ -243,15 +237,15 @@ export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }:
  * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
  * ```
  */
-export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): KubbFile.File {
+export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): FabricFile.File {
   const pathMode = getMode(path.resolve(context.root, context.output.path))
   const resolvedName = pathMode === 'single' ? '' : this.default(name, 'file')
-  const baseName = `${resolvedName}${extname}` as KubbFile.BaseName
+  const baseName = `${resolvedName}${extname}` as FabricFile.BaseName
   const filePath = this.resolvePath({ baseName, pathMode, tag, path: groupPath }, context)
 
   return {
     path: filePath,
-    baseName: path.basename(filePath) as KubbFile.BaseName,
+    baseName: path.basename(filePath) as FabricFile.BaseName,
     meta: {
       pluginName: this.pluginName,
     },
@@ -397,7 +391,7 @@ export function defaultResolveFooter(node: RootNode | undefined, { output }: Res
  * - `default` — name casing strategy (camelCase / PascalCase)
  * - `resolveOptions` — include/exclude/override filtering
  * - `resolvePath` — output path computation
- * - `resolveFile` — full `KubbFile.File` construction
+ * - `resolveFile` — full `FabricFile.File` construction
  *
  * Methods in the builder have access to `this` (the full resolver object), so they
  * can call other resolver methods without circular imports.

package/src/hooks/useDriver.ts

@@ -1,6 +1,9 @@
 import { useFabric } from '@kubb/react-fabric'
 import type { PluginDriver } from '../PluginDriver.ts'
 
+/**
+ * @deprecated use `driver` from the generator component props instead
+ */
 export function useDriver(): PluginDriver {
   const { meta } = useFabric<{ driver: PluginDriver }>()
 

package/src/hooks/useMode.ts

@@ -1,11 +1,11 @@
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import { useFabric } from '@kubb/react-fabric'
 
 /**
  * @deprecated use `mode` from the generator component props instead
  */
-export function useMode(): KubbFile.Mode {
-  const { meta } = useFabric<{ mode: KubbFile.Mode }>()
+export function useMode(): FabricFile.Mode {
+  const { meta } = useFabric<{ mode: FabricFile.Mode }>()
 
   return meta.mode
 }

package/src/index.ts

@@ -6,10 +6,8 @@ export { formatters, linters, logLevel } from './constants.ts'
 export { createAdapter } from './createAdapter.ts'
 export { createPlugin } from './createPlugin.ts'
 export { createStorage } from './createStorage.ts'
-export { defineBuilder } from './defineBuilder.ts'
 export { defineGenerator } from './defineGenerator.ts'
 export { defineLogger } from './defineLogger.ts'
-export { definePreset } from './definePreset.ts'
 export { definePresets } from './definePresets.ts'
 export {
   buildDefaultBanner,

package/src/renderNode.tsx

@@ -12,6 +12,7 @@ type BuildOperationsV2Options<TOptions extends PluginFactoryOptions> = {
   adapter: Adapter
   driver: PluginDriver
   options: TOptions['resolvedOptions']
+  resolver: TOptions['resolver']
 }
 
 /**
@@ -30,8 +31,8 @@ export async function renderOperations<TOptions extends PluginFactoryOptions>(
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin, driver }}>
-      <Component config={config} plugin={plugin} adapter={adapter} nodes={nodes} options={options.options} />
+    <Fabric>
+      <Component config={config} plugin={plugin} driver={driver} adapter={adapter} nodes={nodes} options={options.options} resolver={options.resolver} />
     </Fabric>,
   )
 
@@ -47,6 +48,7 @@ type BuildOperationV2Options<TOptions extends PluginFactoryOptions> = {
   adapter: Adapter
   driver: PluginDriver
   options: TOptions['resolvedOptions']
+  resolver: TOptions['resolver']
 }
 
 /**
@@ -62,8 +64,8 @@ export async function renderOperation<TOptions extends PluginFactoryOptions>(nod
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin, driver }}>
-      <Component config={config} plugin={plugin} adapter={adapter} node={node} options={options.options} />
+    <Fabric>
+      <Component config={config} plugin={plugin} driver={driver} adapter={adapter} node={node} options={options.options} resolver={options.resolver} />
     </Fabric>,
   )
 
@@ -79,6 +81,7 @@ type BuildSchemaV2Options<TOptions extends PluginFactoryOptions> = {
   adapter: Adapter
   driver: PluginDriver
   options: TOptions['resolvedOptions']
+  resolver: TOptions['resolver']
 }
 
 /**
@@ -94,8 +97,8 @@ export async function renderSchema<TOptions extends PluginFactoryOptions>(node:
   const fabricChild = createReactFabric()
 
   await fabricChild.render(
-    <Fabric meta={{ plugin, driver }}>
-      <Component config={config} plugin={plugin} adapter={adapter} node={node} options={options.options} />
+    <Fabric>
+      <Component config={config} plugin={plugin} driver={driver} adapter={adapter} node={node} options={options.options} resolver={options.resolver} />
     </Fabric>,
   )
 

package/src/types.ts

@@ -1,6 +1,6 @@
 import type { AsyncEventEmitter, PossiblePromise } from '@internals/utils'
 import type { Node, RootNode, SchemaNode, Visitor } from '@kubb/ast/types'
-import type { Fabric as FabricType, KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile, Fabric as FabricType } from '@kubb/fabric-core/types'
 import type { HttpMethod } from '@kubb/oas'
 import type { DEFAULT_STUDIO_URL, logLevel } from './constants.ts'
 import type { Storage } from './createStorage.ts'
@@ -119,13 +119,13 @@ export type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptio
    */
   parse: (source: AdapterSource) => PossiblePromise<RootNode>
   /**
-   * Extracts `KubbFile.Import` entries needed by a `SchemaNode` tree.
+   * Extracts `FabricFile.Import` entries needed by a `SchemaNode` tree.
    * Populated after the first `parse()` call. Returns an empty array before that.
    *
    * The `resolve` callback receives the collision-corrected schema name and must
    * return the `{ name, path }` pair for the import, or `undefined` to skip it.
    */
-  getImports: (node: SchemaNode, resolve: (schemaName: string) => { name: string; path: string }) => Array<KubbFile.Import>
+  getImports: (node: SchemaNode, resolve: (schemaName: string) => { name: string; path: string }) => Array<FabricFile.Import>
 }
 
 export type BarrelType = 'all' | 'named' | 'propagate'
@@ -227,7 +227,7 @@ export type Config<TInput = Input> = {
      * Overrides the extension for generated imports and exports. By default, each plugin adds an extension.
      * @default { '.ts': '.ts'}
      */
-    extension?: Record<KubbFile.Extname, KubbFile.Extname | ''>
+    extension?: Record<FabricFile.Extname, FabricFile.Extname | ''>
     /**
      * Configures how `index.ts` files are created, including disabling barrel file generation. Each plugin has its own `barrelType` option; this setting controls the root barrel file (e.g., `src/gen/index.ts`).
      * @default 'named'
@@ -254,7 +254,7 @@ export type Config<TInput = Input> = {
    * Each plugin may include additional configurable options(defined in the plugin itself).
    * If a plugin depends on another plugin, an error is returned if the required dependency is missing. See pre for more details.
    */
-  plugins?: Array<Plugin>
+  plugins: Array<Plugin>
   /**
    * Devtools configuration for Kubb Studio integration.
    */
@@ -281,15 +281,25 @@ export type Config<TInput = Input> = {
 
 // plugin
 
+/**
+ * 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.
+ */
 export type ResolveOptionsContext<TOptions> = {
   options: TOptions
   exclude?: Array<PatternFilter>
@@ -317,8 +327,8 @@ export type Resolver = {
   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): KubbFile.Path
-  resolveFile(params: ResolverFileParams, context: ResolverContext): KubbFile.File
+  resolvePath(params: ResolverPathParams, context: ResolverContext): FabricFile.Path
+  resolveFile(params: ResolverFileParams, context: ResolverContext): FabricFile.File
   resolveBanner(node: RootNode | null, context: ResolveBannerContext): string | undefined
   resolveFooter(node: RootNode | null, context: ResolveBannerContext): string | undefined
 }
@@ -339,15 +349,6 @@ export type Resolver = {
  */
 export type UserResolver = Omit<Resolver, 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>
 
-/**
- * Base type for plugin builder objects.
- * Concrete plugin builder types extend this with their own schema-building helpers.
- * Use `defineBuilder` to define a builder object and export it alongside the plugin.
- */
-export type Builder = {
-  name: string
-}
-
 export type PluginFactoryOptions<
   /**
    * Name to be used for the plugin.
@@ -374,11 +375,6 @@ export type PluginFactoryOptions<
    * Use `defineResolver` to define the resolver object and export it alongside the plugin.
    */
   TResolver extends Resolver = Resolver,
-  /**
-   * Builder object that encapsulates the schema-building helpers used by this plugin.
-   * Use `defineBuilder` to define the builder object and export it alongside the plugin.
-   */
-  TBuilder extends Builder = Builder,
 > = {
   name: TName
   options: TOptions
@@ -386,7 +382,6 @@ export type PluginFactoryOptions<
   context: TContext
   resolvePathOptions: TResolvePathOptions
   resolver: TResolver
-  builder: TBuilder
 }
 
 export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
@@ -400,6 +395,10 @@ export type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
   options: TOptions['resolvedOptions']
+  /**
+   * The resolver for this plugin, accessible via `driver.getPluginByName(name)?.resolver`.
+   */
+  resolver?: TOptions['resolver']
   /**
    * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin is executed after these plugins.
    * Can be used to validate dependent plugins.
@@ -435,6 +434,10 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * Options set for a specific plugin(see kubb.config.js), passthrough of options.
    */
   options: TOptions['resolvedOptions']
+  /**
+   * The resolver for this plugin, accessible via `driver.getPluginByName(name)?.resolver`.
+   */
+  resolver: TOptions['resolver']
 
   install: (this: PluginContext<TOptions>, context: PluginContext<TOptions>) => PossiblePromise<void>
   /**
@@ -458,7 +461,12 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    * @deprecated this will be replaced by resolvers
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: KubbFile.BaseName, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.Path
+  resolvePath?: (
+    this: PluginContext<TOptions>,
+    baseName: FabricFile.BaseName,
+    mode?: FabricFile.Mode,
+    options?: TOptions['resolvePathOptions'],
+  ) => FabricFile.Path
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -475,8 +483,8 @@ export type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Require
 
 export type ResolvePathParams<TOptions = object> = {
   pluginName?: string
-  baseName: KubbFile.BaseName
-  mode?: KubbFile.Mode
+  baseName: FabricFile.BaseName
+  mode?: FabricFile.Mode
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
@@ -501,20 +509,24 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
   fabric: FabricType
   config: Config
   driver: PluginDriver
+  getPlugin: PluginDriver['getPlugin']
   /**
    * Only add when the file does not exist yet
    */
-  addFile: (...file: Array<KubbFile.File>) => Promise<void>
+  addFile: (...file: Array<FabricFile.File>) => Promise<void>
   /**
    * merging multiple sources into the same output file
    */
-  upsertFile: (...file: Array<KubbFile.File>) => Promise<void>
+  upsertFile: (...file: Array<FabricFile.File>) => Promise<void>
   events: AsyncEventEmitter<KubbEvents>
-  mode: KubbFile.Mode
   /**
    * Current plugin
    */
   plugin: Plugin<TOptions>
+  /**
+   * Resolver for the current plugin. Shorthand for `plugin.resolver`.
+   */
+  resolver: TOptions['resolver']
 
   /**
    * Opens the Kubb Studio URL for the current `rootNode` in the default browser.
@@ -568,7 +580,7 @@ export type Output<_TOptions = unknown> = {
   override?: boolean
 }
 
-export type Group = {
+export type UserGroup = {
   /**
    * Defines the type where to group the files.
    * - 'tag' groups files by OpenAPI tags.
@@ -582,6 +594,20 @@ export type Group = {
   name?: (context: { group: string }) => string
 }
 
+export type Group = {
+  /**
+   * Defines the type where to group the files.
+   * - 'tag' groups files by OpenAPI tags.
+   * - 'path' groups files by OpenAPI paths.
+   * @default undefined
+   */
+  type: 'tag' | 'path'
+  /**
+   * Return the name of a group based on the group name, this is used for the file and name generation.
+   */
+  name: (context: { group: string }) => string
+}
+
 export type LoggerOptions = {
   /**
    * @default 3
@@ -714,8 +740,8 @@ export type ResolvePathOptions = {
  * ```
  */
 export type ResolverPathParams = {
-  baseName: KubbFile.BaseName
-  pathMode?: KubbFile.Mode
+  baseName: FabricFile.BaseName
+  pathMode?: FabricFile.Mode
   /**
    * Tag value used when `group.type === 'tag'`.
    */
@@ -745,7 +771,9 @@ export type ResolverContext = {
   root: string
   output: Output
   group?: Group
-  /** Plugin name used to populate `meta.pluginName` on the resolved file. */
+  /**
+   * Plugin name used to populate `meta.pluginName` on the resolved file.
+   */
   pluginName?: string
 }
 
@@ -766,10 +794,14 @@ export type ResolverContext = {
  */
 export type ResolverFileParams = {
   name: string
-  extname: KubbFile.Extname
-  /** Tag value used when `group.type === 'tag'`. */
+  extname: FabricFile.Extname
+  /**
+   * Tag value used when `group.type === 'tag'`.
+   */
   tag?: string
-  /** Path value used when `group.type === 'path'`. */
+  /**
+   * Path value used when `group.type === 'path'`.
+   */
   path?: string
 }
 

package/src/utils/TreeNode.ts

@@ -1,20 +1,20 @@
 import path from 'node:path'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import { getMode } from '../PluginDriver.ts'
 
 type BarrelData = {
-  file?: KubbFile.File
+  file?: FabricFile.File
   /**
    * @deprecated use file instead
    */
-  type: KubbFile.Mode
+  type: FabricFile.Mode
   path: string
   name: string
 }
 
 /**
  * Tree structure used to build per-directory barrel (`index.ts`) files from a
- * flat list of generated {@link KubbFile.File} entries.
+ * flat list of generated {@link FabricFile.File} entries.
  *
  * Each node represents either a directory or a file within the output tree.
  * Use {@link TreeNode.build} to construct a root node from a file list, then
@@ -76,6 +76,9 @@ export class TreeNode {
     return leaves
   }
 
+  /**
+   * Visits this node and every descendant in depth-first order.
+   */
   forEach(callback: (treeNode: TreeNode) => void): this {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -90,6 +93,9 @@ export class TreeNode {
     return this
   }
 
+  /**
+   * Finds the first leaf that satisfies `predicate`, or `undefined` when none match.
+   */
   findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
     if (typeof predicate !== 'function') {
       throw new TypeError('find() predicate must be a function')
@@ -98,6 +104,9 @@ export class TreeNode {
     return this.leaves.find(predicate)
   }
 
+  /**
+   * Calls `callback` for every leaf of this node.
+   */
   forEachDeep(callback: (treeNode: TreeNode) => void): void {
     if (typeof callback !== 'function') {
       throw new TypeError('forEach() callback must be a function')
@@ -106,6 +115,9 @@ export class TreeNode {
     this.leaves.forEach(callback)
   }
 
+  /**
+   * Returns all leaves that satisfy `callback`.
+   */
   filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
     if (typeof callback !== 'function') {
       throw new TypeError('filter() callback must be a function')
@@ -114,6 +126,9 @@ export class TreeNode {
     return this.leaves.filter(callback)
   }
 
+  /**
+   * Maps every leaf through `callback` and returns the resulting array.
+   */
   mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
     if (typeof callback !== 'function') {
       throw new TypeError('map() callback must be a function')
@@ -128,7 +143,7 @@ export class TreeNode {
    * - Filters to files under `root` (when provided) and skips `.json` files.
    * - Returns `null` when no files match.
    */
-  public static build(files: KubbFile.File[], root?: string): TreeNode | null {
+  public static build(files: FabricFile.File[], root?: string): TreeNode | null {
     try {
       const filteredTree = buildDirectoryTree(files, root)
 
@@ -172,13 +187,13 @@ export class TreeNode {
 type DirectoryTree = {
   name: string
   path: string
-  file?: KubbFile.File
+  file?: FabricFile.File
   children: Array<DirectoryTree>
 }
 
 const normalizePath = (p: string): string => p.replaceAll('\\', '/')
 
-function buildDirectoryTree(files: Array<KubbFile.File>, rootFolder = ''): DirectoryTree | null {
+function buildDirectoryTree(files: Array<FabricFile.File>, rootFolder = ''): DirectoryTree | null {
   const normalizedRootFolder = normalizePath(rootFolder)
   const rootPrefix = normalizedRootFolder.endsWith('/') ? normalizedRootFolder : `${normalizedRootFolder}/`
 

package/src/utils/getBarrelFiles.ts

@@ -1,7 +1,7 @@
 /** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
 import { join } from 'node:path'
 import { getRelativePath } from '@internals/utils'
-import type { KubbFile } from '@kubb/fabric-core/types'
+import type { FabricFile } from '@kubb/fabric-core/types'
 import type { BarrelType } from '../types.ts'
 import { TreeNode } from './TreeNode.ts'
 
@@ -29,16 +29,16 @@ type AddIndexesProps = {
   meta?: FileMetaBase
 }
 
-function getBarrelFilesByRoot(root: string | undefined, files: Array<KubbFile.ResolvedFile>): Array<KubbFile.File> {
-  const cachedFiles = new Map<KubbFile.Path, KubbFile.File>()
+function getBarrelFilesByRoot(root: string | undefined, files: Array<FabricFile.ResolvedFile>): Array<FabricFile.File> {
+  const cachedFiles = new Map<FabricFile.Path, FabricFile.File>()
 
   TreeNode.build(files, root)?.forEach((treeNode) => {
     if (!treeNode?.children || !treeNode.parent?.data.path) {
       return
     }
 
-    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as KubbFile.Path
-    const barrelFile: KubbFile.File = {
+    const barrelFilePath = join(treeNode.parent?.data.path, 'index.ts') as FabricFile.Path
+    const barrelFile: FabricFile.File = {
       path: barrelFilePath,
       baseName: 'index.ts',
       exports: [],
@@ -113,7 +113,10 @@ function trimExtName(text: string): string {
  * - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
  * - Attaches `meta` to each barrel file for downstream plugin identification.
  */
-export async function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, { type, meta = {}, root, output }: AddIndexesProps): Promise<Array<KubbFile.File>> {
+export async function getBarrelFiles(
+  files: Array<FabricFile.ResolvedFile>,
+  { type, meta = {}, root, output }: AddIndexesProps,
+): Promise<Array<FabricFile.File>> {
   if (!type || type === 'propagate') {
     return []
   }

package/src/utils/getConfigs.ts

@@ -12,5 +12,5 @@ export async function getConfigs(config: ConfigInput | UserConfig, args: CLIOpti
   const resolved = await (typeof config === 'function' ? config(args as CLIOptions) : config)
   const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
 
-  return userConfigs.map((item) => ({ ...item }) as Config)
+  return userConfigs.map((item) => ({ plugins: [], ...item }) as Config)
 }