@kubb/core 5.0.0-alpha.20 → 5.0.0-alpha.22

package/dist/{PluginDriver-BkSenc-R.d.ts → PluginDriver-DZdEyCoa.d.ts}

@@ -1,6 +1,7 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
 import { Node, OperationNode, Printer, PrinterFactoryOptions, RootNode, SchemaNode, Visitor } from "@kubb/ast/types";
-import { Fabric, KubbFile } from "@kubb/fabric-core/types";
+import { Fabric, FabricFile } from "@kubb/fabric-core/types";
+import { HttpMethod } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";
 
 //#region ../../internals/utils/src/asyncEventEmitter.d.ts
@@ -210,6 +211,109 @@ type Storage = {
  */
 declare function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage;
 //#endregion
+//#region src/defineGenerator.d.ts
+/**
+ * Props for the `operations` lifecycle — receives all operation nodes at once.
+ */
+type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  plugin: Plugin<TPlugin>;
+  adapter: Adapter;
+  options: Plugin<TPlugin>['options'];
+  nodes: Array<OperationNode>;
+};
+/**
+ * Props for the `operation` lifecycle — receives a single operation node.
+ */
+type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  plugin: Plugin<TPlugin>;
+  options: Plugin<TPlugin>['options'];
+  node: OperationNode;
+};
+/**
+ * Props for the `schema` lifecycle — receives a single schema node.
+ */
+type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  config: Config;
+  adapter: Adapter;
+  plugin: Plugin<TPlugin>;
+  options: Plugin<TPlugin>['options'];
+  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<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';
+  version?: '2';
+  Operations?(props: OperationsV2Props<TPlugin>): FabricReactNode;
+  Operation?(props: OperationV2Props<TPlugin>): FabricReactNode;
+  Schema?(props: SchemaV2Props<TPlugin>): FabricReactNode;
+};
+/**
+ * A fully resolved core v2 generator with `version: '2'` and guaranteed async lifecycle methods.
+ */
+type CoreGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  version: '2';
+  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.
+ */
+type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  version: '2';
+  Operations(props: OperationsV2Props<TPlugin>): FabricReactNode;
+  Operation(props: OperationV2Props<TPlugin>): FabricReactNode;
+  Schema(props: SchemaV2Props<TPlugin>): FabricReactNode;
+};
+/**
+ * Union of all v2 generator shapes accepted by the plugin system.
+ */
+type Generator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>;
+/**
+ * Defines a generator with no-op defaults for any omitted lifecycle methods.
+ * Works for both `core` (async file output) and `react` (JSX component) generators.
+ *
+ * @example
+ * // react generator
+ * export const typeGenerator = defineGenerator<PluginTs>({
+ *   name: 'typescript',
+ *   type: 'react',
+ *   Operation({ node, options }) { return <File>...</File> },
+ *   Schema({ node, options }) { return <File>...</File> },
+ * })
+ *
+ * @example
+ * // core generator
+ * export const myGenerator = defineGenerator<MyPlugin>({
+ *   name: 'my-generator',
+ *   type: 'core',
+ *   async operation({ node, options }) { return [{ path: '...', content: '...' }] },
+ * })
+ */
+declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserReactGeneratorV2<TPlugin>): ReactGeneratorV2<TPlugin>;
+declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserCoreGeneratorV2<TPlugin>): CoreGeneratorV2<TPlugin>;
+//#endregion
 //#region src/Kubb.d.ts
 type DebugInfo = {
   date: Date;
@@ -279,7 +383,7 @@ interface KubbEvents {
   /**
    * Emitted when code generation phase completes.
    */
-  'generation:end': [config: Config, files: Array<KubbFile.ResolvedFile>, sources: Map<KubbFile.Path, string>];
+  'generation:end': [config: Config, files: Array<FabricFile.ResolvedFile>, sources: Map<FabricFile.Path, string>];
   /**
    * Emitted with a summary of the generation results.
    * Contains summary lines, title, and success status.
@@ -366,7 +470,7 @@ interface KubbEvents {
    * Emitted when file processing starts.
    * Contains the list of files to be processed.
    */
-  'files:processing:start': [files: Array<KubbFile.ResolvedFile>];
+  'files:processing:start': [files: Array<FabricFile.ResolvedFile>];
   /**
    * Emitted for each file being processed, providing progress updates.
    * Contains processed count, total count, percentage, and file details.
@@ -391,7 +495,7 @@ interface KubbEvents {
     /**
      * The file being processed.
      */
-    file: KubbFile.ResolvedFile;
+    file: FabricFile.ResolvedFile;
     /**
      * Kubb configuration (not present in Fabric).
      * Provides access to the current config during file processing.
@@ -402,7 +506,7 @@ interface KubbEvents {
    * Emitted when file processing completes.
    * Contains the list of processed files.
    */
-  'files:processing:end': [files: Array<KubbFile.ResolvedFile>];
+  'files:processing:end': [files: Array<FabricFile.ResolvedFile>];
   /**
    * Emitted when a plugin starts executing.
    */
@@ -440,91 +544,6 @@ interface KubbEvents {
   'plugins:hook:processing:end': [result: HookResult];
 }
 //#endregion
-//#region src/defineGenerator.d.ts
-/**
- * Props for the `operations` lifecycle — receives all operation nodes at once.
- */
-type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config;
-  adapter: Adapter;
-  options: Plugin<TPlugin>['options'];
-  nodes: Array<OperationNode>;
-};
-/**
- * Props for the `operation` lifecycle — receives a single operation node.
- */
-type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config;
-  adapter: Adapter;
-  options: Plugin<TPlugin>['options'];
-  node: OperationNode;
-};
-/**
- * Props for the `schema` lifecycle — receives a single schema node.
- */
-type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config;
-  adapter: Adapter;
-  options: Plugin<TPlugin>['options'];
-  node: SchemaNode;
-};
-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>>;
-};
-type UserReactGeneratorV2<TPlugin extends PluginFactoryOptions> = {
-  name: string;
-  type: 'react';
-  version?: '2';
-  Operations?(props: OperationsV2Props<TPlugin>): FabricReactNode;
-  Operation?(props: OperationV2Props<TPlugin>): FabricReactNode;
-  Schema?(props: SchemaV2Props<TPlugin>): FabricReactNode;
-};
-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>>;
-};
-type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  name: string;
-  type: 'react';
-  version: '2';
-  Operations(props: OperationsV2Props<TPlugin>): FabricReactNode;
-  Operation(props: OperationV2Props<TPlugin>): FabricReactNode;
-  Schema(props: SchemaV2Props<TPlugin>): FabricReactNode;
-};
-type Generator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>;
-/**
- * Defines a generator with no-op defaults for any omitted lifecycle methods.
- * Works for both `core` (async file output) and `react` (JSX component) generators.
- *
- * @example
- * // react generator
- * export const typeGenerator = defineGenerator<PluginTs>({
- *   name: 'typescript',
- *   type: 'react',
- *   Operation({ node, options }) { return <File>...</File> },
- *   Schema({ node, options }) { return <File>...</File> },
- * })
- *
- * @example
- * // core generator
- * export const myGenerator = defineGenerator<MyPlugin>({
- *   name: 'my-generator',
- *   type: 'core',
- *   async operation({ node, options }) { return [{ path: '...', content: '...' }] },
- * })
- */
-declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserReactGeneratorV2<TPlugin>): ReactGeneratorV2<TPlugin>;
-declare function defineGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserCoreGeneratorV2<TPlugin>): CoreGeneratorV2<TPlugin>;
-//#endregion
 //#region src/types.d.ts
 declare global {
   namespace Kubb {
@@ -624,13 +643,14 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
    * The raw source document produced after the first `parse()` call.
    * `undefined` before parsing; typed by the adapter's `TDocument` generic.
    */
-  document?: TOptions['document'];
+  document: TOptions['document'] | null;
+  rootNode: RootNode | null;
   /**
    * Convert the raw source into a universal `RootNode`.
    */
   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
@@ -639,7 +659,7 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
   getImports: (node: SchemaNode, resolve: (schemaName: string) => {
     name: string;
     path: string;
-  }) => Array<KubbFile.Import>;
+  }) => Array<FabricFile.Import>;
 };
 type BarrelType = 'all' | 'named' | 'propagate';
 type DevtoolsOptions = {
@@ -738,12 +758,12 @@ 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'
      */
-    barrelType?: Exclude<BarrelType, 'propagate'> | false;
+    barrelType?: 'all' | 'named' | false;
     /**
      * Adds a default banner to the start of every generated file indicating it was generated by Kubb.
      * - 'simple' adds banner with link to Kubb.
@@ -787,13 +807,23 @@ type Config<TInput = Input> = {
     done?: string | Array<string>;
   };
 };
+/**
+ * A type/string-pattern filter used for `include`, `exclude`, and `override` matching.
+ */
 type PatternFilter = {
   type: string;
   pattern: string | RegExp;
 };
+/**
+ * A pattern filter paired with partial option overrides to apply when the pattern matches.
+ */
 type PatternOverride<TOptions> = PatternFilter & {
   options: Omit<Partial<TOptions>, 'override'>;
 };
+/**
+ * Context passed to `resolver.resolveOptions` to apply include/exclude/override filtering
+ * for a given operation or schema node.
+ */
 type ResolveOptionsContext<TOptions> = {
   options: TOptions;
   exclude?: Array<PatternFilter>;
@@ -803,24 +833,51 @@ type ResolveOptionsContext<TOptions> = {
 /**
  * Base constraint for all plugin resolver objects.
  *
- * `default` and `resolveOptions` are injected automatically by `defineResolver` — plugin
- * authors may override them but never need to implement them from scratch.
- * Concrete plugin resolver types extend this with their own helper methods.
+ * `default`, `resolveOptions`, `resolvePath`, and `resolveFile` are injected automatically
+ * by `defineResolver` — plugin authors may override them but never need to implement them
+ * from scratch.
+ *
+ * @example
+ * ```ts
+ * type MyResolver = Resolver & {
+ *   resolveName(node: SchemaNode): string
+ *   resolveTypedName(node: SchemaNode): string
+ * }
+ * ```
  */
 type Resolver = {
   name: string;
+  pluginName: Plugin['name'];
   default(name: ResolveNameParams['name'], type?: ResolveNameParams['type']): string;
   resolveOptions<TOptions>(node: Node, context: ResolveOptionsContext<TOptions>): TOptions | null;
+  resolvePath(params: ResolverPathParams, context: ResolverContext): 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;
 };
 /**
- * The user-facing subset of a `Resolver` — everything except the methods injected by
- * `defineResolver` (`default` and `resolveOptions`).
+ * The user-facing subset of a `Resolver` — everything except the four methods injected by
+ * `defineResolver` (`default`, `resolveOptions`, `resolvePath`, and `resolveFile`).
  *
- * When you pass a `UserResolver` to `defineResolver`, the standard `default` and
- * `resolveOptions` implementations are injected automatically so plugin authors never
- * need to define them by hand. Both can still be overridden by providing them explicitly.
+ * All four injected methods can still be overridden by providing them explicitly in the builder.
+ *
+ * @example
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
+ *   resolveName(node) { return this.default(node.name, 'function') },
+ * }))
+ * ```
  */
-type UserResolver = Omit<Resolver, 'default' | 'resolveOptions'>;
+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.
+ */
+type Builder = {
+  name: string;
+};
 type PluginFactoryOptions<
 /**
  * Name to be used for the plugin.
@@ -846,13 +903,19 @@ TResolvePathOptions extends object = object,
  * Resolver object that encapsulates the naming and path-resolution helpers used by this plugin.
  * Use `defineResolver` to define the resolver object and export it alongside the plugin.
  */
-TResolver extends Resolver = Resolver> = {
+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;
   resolvedOptions: TResolvedOptions;
   context: TContext;
   resolvePathOptions: TResolvePathOptions;
   resolver: TResolver;
+  builder: TBuilder;
 };
 type UserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
@@ -915,13 +978,15 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    * Options can als be included.
    * @type hookFirst
    * @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.
    * @type hookFirst
    * @example ('pet') => 'Pet'
+   * @deprecated this will be replaced by resolvers
    */
   resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
 };
@@ -929,8 +994,8 @@ type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
 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
    */
@@ -956,13 +1021,13 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   /**
    * 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;
+  mode: FabricFile.Mode;
   /**
    * Current plugin
    */
@@ -990,7 +1055,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
 /**
  * Specify the export location for the files and define the behavior of the output
  */
-type Output<TOptions> = {
+type Output<_TOptions = unknown> = {
   /**
    * Path to the output folder or file that will contain the generated code
    */
@@ -1003,11 +1068,11 @@ type Output<TOptions> = {
   /**
    * Add a banner text in the beginning of every file
    */
-  banner?: string | ((options: TOptions) => string);
+  banner?: string | ((node: RootNode) => string);
   /**
    * Add a footer text in the beginning of every file
    */
-  footer?: string | ((options: TOptions) => string);
+  footer?: string | ((node: RootNode) => string);
   /**
    * Whether to override existing external files if they already exist.
    * @default false
@@ -1051,8 +1116,8 @@ type UserLogger<TOptions extends LoggerOptions = LoggerOptions> = Logger<TOption
  */
 type CompatibilityPreset = 'default' | 'kubbV4';
 /**
- * A preset bundles a name, one or more resolvers, and optional AST transformers
- * into a single reusable configuration object.
+ * A preset bundles a name, one or more resolvers, optional AST transformers,
+ * and optional generators into a single reusable configuration object.
  *
  * @template TResolver - The concrete resolver type for this preset.
  */
@@ -1069,6 +1134,11 @@ type Preset<TResolver extends Resolver = Resolver> = {
    * Optional AST visitors / transformers applied after resolving.
    */
   transformers?: Array<Visitor>;
+  /**
+   * Optional generators used by this preset. Plugin implementations cast this
+   * to their concrete generator type.
+   */
+  generators?: Array<Generator<any>>;
 };
 /**
  * A named registry of presets, keyed by preset name.
@@ -1077,9 +1147,148 @@ type Preset<TResolver extends Resolver = Resolver> = {
  * @template TName - The union of valid preset name keys.
  */
 type Presets<TResolver extends Resolver = Resolver> = Record<CompatibilityPreset, Preset<TResolver>>;
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType | BySchemaName;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+type ResolvePathOptions = {
+  pluginName?: string;
+  group?: {
+    tag?: string;
+    path?: string;
+  };
+  type?: ResolveNameParams['type'];
+};
+/**
+ * File-specific parameters for `Resolver.resolvePath`.
+ *
+ * Pass alongside a `ResolverContext` to identify which file to resolve.
+ * Provide `tag` for tag-based grouping or `path` for path-based grouping.
+ *
+ * @example
+ * ```ts
+ * resolver.resolvePath(
+ *   { baseName: 'petTypes.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → '/src/types/petsController/petTypes.ts'
+ * ```
+ */
+type ResolverPathParams = {
+  baseName: FabricFile.BaseName;
+  pathMode?: FabricFile.Mode;
+  /**
+   * Tag value used when `group.type === 'tag'`.
+   */
+  tag?: string;
+  /**
+   * Path value used when `group.type === 'path'`.
+   */
+  path?: string;
+};
+/**
+ * Shared context passed as the second argument to `Resolver.resolvePath` and `Resolver.resolveFile`.
+ *
+ * Describes where on disk output is rooted, which output config is active, and the optional
+ * grouping strategy that controls subdirectory layout.
+ *
+ * @example
+ * ```ts
+ * const context: ResolverContext = {
+ *   root: config.root,
+ *   output,
+ *   group,
+ * }
+ * ```
+ */
+type ResolverContext = {
+  root: string;
+  output: Output;
+  group?: Group;
+  /**
+   * Plugin name used to populate `meta.pluginName` on the resolved file.
+   */
+  pluginName?: string;
+};
+/**
+ * File-specific parameters for `Resolver.resolveFile`.
+ *
+ * Pass alongside a `ResolverContext` to fully describe the file to resolve.
+ * `tag` and `path` are used only when a matching `group` is present in the context.
+ *
+ * @example
+ * ```ts
+ * resolver.resolveFile(
+ *   { name: 'listPets', extname: '.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+ * ```
+ */
+type ResolverFileParams = {
+  name: string;
+  extname: FabricFile.Extname;
+  /**
+   * Tag value used when `group.type === 'tag'`.
+   */
+  tag?: string;
+  /**
+   * Path value used when `group.type === 'path'`.
+   */
+  path?: string;
+};
+/**
+ * Context passed to `Resolver.resolveBanner` and `Resolver.resolveFooter`.
+ *
+ * `output` is optional — not every plugin configures a banner/footer.
+ * `config` carries the global Kubb config, used to derive the default Kubb banner.
+ *
+ * @example
+ * ```ts
+ * resolver.resolveBanner(rootNode, { output: { banner: '// generated' }, config })
+ * // → '// generated'
+ * ```
+ */
+type ResolveBannerContext = {
+  output?: Pick<Output, 'banner' | 'footer'>;
+  config: Config;
+};
 //#endregion
 //#region src/PluginDriver.d.ts
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
+/**
+ * Hook dispatch strategy used by the `PluginDriver`.
+ *
+ * - `hookFirst` — stops at the first non-null result.
+ * - `hookForPlugin` — calls only the matching plugin.
+ * - `hookParallel` — calls all plugins concurrently.
+ * - `hookSeq` — calls all plugins in order, threading the result.
+ */
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq';
 type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
@@ -1094,14 +1303,26 @@ type Options = {
    */
   concurrency?: number;
 };
+/**
+ * Parameters accepted by `PluginDriver.getFile` to resolve a generated file descriptor.
+ */
 type GetFileOptions<TOptions = object> = {
   name: string;
-  mode?: KubbFile.Mode;
-  extname: KubbFile.Extname;
+  mode?: FabricFile.Mode;
+  extname: FabricFile.Extname;
   pluginName: string;
   options?: TOptions;
 };
-declare function getMode(fileOrFolder: string | undefined | null): KubbFile.Mode;
+/**
+ * Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+ *
+ * @example
+ * ```ts
+ * getMode('src/gen/types.ts')  // 'single'
+ * getMode('src/gen/types')     // 'split'
+ * ```
+ */
+declare function getMode(fileOrFolder: string | undefined | null): FabricFile.Mode;
 declare class PluginDriver {
   #private;
   readonly config: Config;
@@ -1122,10 +1343,10 @@ declare class PluginDriver {
     extname,
     pluginName,
     options
-  }: GetFileOptions<TOptions>): KubbFile.File<{
+  }: GetFileOptions<TOptions>): FabricFile.File<{
     pluginName: string;
   }>;
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.Path;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => FabricFile.Path;
   resolveName: (params: ResolveNameParams) => string;
   /**
    * Run a specific hookName for plugin x.
@@ -1199,5 +1420,5 @@ declare class PluginDriver {
   getPluginsByName(hookName: keyof PluginWithLifeCycle, pluginName: string): Plugin[];
 }
 //#endregion
-export { ResolveOptionsContext as A, ReactGeneratorV2 as B, PluginParameter as C, Printer as D, Presets as E, UserPlugin as F, formatters as G, KubbEvents as H, UserPluginWithLifeCycle as I, PossiblePromise as J, linters as K, UserResolver as L, Resolver as M, UserConfig as N, PrinterFactoryOptions as O, UserLogger as P, CoreGeneratorV2 as R, PluginLifecycleHooks as S, Preset as T, Storage as U, defineGenerator as V, createStorage as W, AsyncEventEmitter as Y, Output as _, AdapterFactoryOptions as a, PluginFactoryOptions as b, CompatibilityPreset as c, Group as d, InputData as f, LoggerOptions as g, LoggerContext as h, Adapter as i, ResolvePathParams as j, ResolveNameParams as k, Config as l, Logger as m, PluginDriver as n, AdapterSource as o, InputPath as p, logLevel as q, getMode as r, BarrelType as s, GetFileOptions as t, DevtoolsOptions as u, Plugin as v, PluginWithLifeCycle as w, PluginLifecycle as x, PluginContext as y, Generator as z };
-//# sourceMappingURL=PluginDriver-BkSenc-R.d.ts.map
+export { formatters as $, Printer as A, ResolverPathParams as B, PluginFactoryOptions as C, PluginWithLifeCycle as D, PluginParameter as E, ResolvePathOptions as F, UserResolver as G, UserLogger as H, ResolvePathParams as I, Generator as J, KubbEvents as K, Resolver as L, ResolveBannerContext as M, ResolveNameParams as N, Preset as O, ResolveOptionsContext as P, createStorage as Q, ResolverContext as R, PluginContext as S, PluginLifecycleHooks as T, UserPlugin as U, UserConfig as V, UserPluginWithLifeCycle as W, defineGenerator as X, ReactGeneratorV2 as Y, Storage as Z, LoggerContext as _, AdapterSource as a, Override as b, CompatibilityPreset as c, Exclude as d, linters as et, Group as f, Logger as g, InputPath as h, AdapterFactoryOptions as i, PrinterFactoryOptions as j, Presets as k, Config as l, InputData as m, getMode as n, PossiblePromise as nt, BarrelType as o, Include as p, CoreGeneratorV2 as q, Adapter as r, AsyncEventEmitter as rt, Builder as s, PluginDriver as t, logLevel as tt, DevtoolsOptions as u, LoggerOptions as v, PluginLifecycle as w, Plugin as x, Output as y, ResolverFileParams as z };
+//# sourceMappingURL=PluginDriver-DZdEyCoa.d.ts.map