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

package/dist/{PluginDriver-D110FoJ-.d.ts → PluginDriver-D0dY_hpJ.d.ts}

@@ -1,6 +1,6 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
+import { n as __name, t as __exportAll } from "./chunk-O_arW02_.js";
 import { Node, OperationNode, Printer, Printer as Printer$1, PrinterFactoryOptions, PrinterPartial, RootNode, SchemaNode, Visitor } from "@kubb/ast/types";
-import { Fabric, FabricFile } from "@kubb/fabric-core/types";
+import { Fabric } from "@kubb/fabric-core/types";
 import { HttpMethod } from "@kubb/oas";
 import { FabricReactNode } from "@kubb/react-fabric/types";
 
@@ -86,6 +86,138 @@ declare class AsyncEventEmitter<TEvents extends { [K in keyof TEvents]: unknown[
  * ```
  */
 type PossiblePromise<T> = Promise<T> | T;
+declare namespace KubbFile_d_exports {
+  export { BaseName, Export, Extname, File, Import, Mode, Path, ResolvedFile, Source };
+}
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
+type Import = {
+  /**
+   * Import name to be used.
+   * @example ["useState"]
+   * @example "React"
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
+   */
+  isNameSpace?: boolean;
+  /**
+   * When root is set it will compute a relative path with `getRelativePath(root, path)`.
+   */
+  root?: string;
+};
+type Source = {
+  name?: string;
+  value?: string;
+  /**
+   * Make this source a type-only export.
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Include export keyword in source.
+   * @default false
+   */
+  isExportable?: boolean;
+  /**
+   * Include in barrel file generation.
+   * @default false
+   */
+  isIndexable?: boolean;
+};
+type Export = {
+  /**
+   * Export name to be used.
+   * @example ["useState"]
+   * @example "React"
+   */
+  name?: string | Array<string>;
+  /**
+   * Path for the export.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Export as aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates standard export
+   * @default false
+   */
+  asAlias?: boolean;
+};
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type Mode = 'single' | 'split';
+/**
+ * Name to be used to dynamically create the baseName (based on input.path).
+ * Based on UNIX basename.
+ * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+ */
+type BaseName = `${string}.${string}`;
+/**
+ * Fully qualified path to a specified file.
+ */
+type Path = string;
+type File<TMeta extends object = object> = {
+  /**
+   * Name used to create the path.
+   * Based on UNIX basename, `${name}${extname}`.
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: BaseName;
+  /**
+   * Fully qualified path to the file.
+   */
+  path: Path;
+  sources: Array<Source>;
+  imports: Array<Import>;
+  exports: Array<Export>;
+  /**
+   * Extra metadata used for barrel/index file generation.
+   */
+  meta?: TMeta;
+  banner?: string;
+  footer?: string;
+};
+type ResolvedFile<TMeta extends object = object> = File<TMeta> & {
+  /**
+   * Unique identifier, generated from a hash.
+   * @default hash
+   */
+  id: string;
+  /**
+   * First part of the `baseName`, derived from the file name.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  extname: Extname;
+  imports: Array<Import>;
+  exports: Array<Export>;
+};
 //#endregion
 //#region src/constants.d.ts
 /**
@@ -218,7 +350,7 @@ declare function createStorage<TOptions = Record<string, never>>(build: (options
  * giving full access to `this.config`, `this.resolver`, `this.adapter`, `this.fabric`,
  * `this.driver`, etc.
  *
- * Return a React element, an array of `FabricFile.File`, or `void` to handle file
+ * Return a React element, an array of `KubbFile.File`, or `void` to handle file
  * writing manually via `this.upsertFile`. Both React and core (non-React) generators
  * use the same method signatures — the return type determines how output is handled.
  *
@@ -243,17 +375,17 @@ type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
    * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
    * `options` contains the per-node resolved options (after exclude/include/override).
    */
-  schema?: (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+  schema?: (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
   /**
    * Called for each operation node in the AST walk.
    * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
    */
-  operation?: (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+  operation?: (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
   /**
    * Called once after all operations have been walked.
    * `this` is the parent plugin's context with `adapter` and `rootNode` guaranteed present.
    */
-  operations?: (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+  operations?: (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
 };
 /**
  * Defines a generator. Returns the object as-is with correct `this` typings.
@@ -285,6 +417,54 @@ declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginF
  */
 declare function mergeGenerators<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(generators: Array<Generator<TOptions>>): Generator<TOptions>;
 //#endregion
+//#region src/defineParser.d.ts
+type PrintOptions = {
+  extname?: Extname;
+};
+type Parser<TMeta extends object = any> = {
+  name: string;
+  type: 'parser';
+  /**
+   * File extensions this parser handles.
+   * Use `undefined` to create a catch-all fallback parser.
+   *
+   * @example ['.ts', '.js']
+   */
+  extNames: Array<Extname> | undefined;
+  /**
+   * @deprecated Will be removed once Fabric no longer requires it.
+   * @default () => {}
+   */
+  install(...args: unknown[]): void | Promise<void>;
+  /**
+   * Convert a resolved file to a string.
+   */
+  parse(file: ResolvedFile<TMeta>, options?: PrintOptions): Promise<string> | string;
+};
+type UserParser<TMeta extends object = any> = Omit<Parser<TMeta>, 'type' | 'install'> & {
+  install?(...args: unknown[]): void | Promise<void>;
+};
+/**
+ * Defines a parser with type safety.
+ *
+ * Use this function to create parsers that transform generated files to strings
+ * based on their extension.
+ *
+ * @example
+ * ```ts
+ * import { defineParser } from '@kubb/core'
+ *
+ * export const jsonParser = defineParser({
+ *   name: 'json',
+ *   extNames: ['.json'],
+ *   parse(file) {
+ *     return file.sources.map((s) => s.value).join('\n')
+ *   },
+ * })
+ * ```
+ */
+declare function defineParser<TMeta extends object = any>(parser: UserParser<TMeta>): Parser<TMeta>;
+//#endregion
 //#region src/Kubb.d.ts
 type DebugInfo = {
   date: Date;
@@ -354,7 +534,7 @@ interface KubbEvents {
   /**
    * Emitted when code generation phase completes.
    */
-  'generation:end': [config: Config, files: Array<FabricFile.ResolvedFile>, sources: Map<FabricFile.Path, string>];
+  'generation:end': [config: Config, files: Array<ResolvedFile>, sources: Map<Path, string>];
   /**
    * Emitted with a summary of the generation results.
    * Contains summary lines, title, and success status.
@@ -441,7 +621,7 @@ interface KubbEvents {
    * Emitted when file processing starts.
    * Contains the list of files to be processed.
    */
-  'files:processing:start': [files: Array<FabricFile.ResolvedFile>];
+  'files:processing:start': [files: Array<ResolvedFile>];
   /**
    * Emitted for each file being processed, providing progress updates.
    * Contains processed count, total count, percentage, and file details.
@@ -466,7 +646,7 @@ interface KubbEvents {
     /**
      * The file being processed.
      */
-    file: FabricFile.ResolvedFile;
+    file: ResolvedFile;
     /**
      * Kubb configuration (not present in Fabric).
      * Provides access to the current config during file processing.
@@ -477,7 +657,7 @@ interface KubbEvents {
    * Emitted when file processing completes.
    * Contains the list of processed files.
    */
-  'files:processing:end': [files: Array<FabricFile.ResolvedFile>];
+  'files:processing:end': [files: Array<ResolvedFile>];
   /**
    * Emitted when a plugin starts executing.
    */
@@ -515,6 +695,132 @@ interface KubbEvents {
   'plugins:hook:processing:end': [result: HookResult];
 }
 //#endregion
+//#region src/defineConfig.d.ts
+/**
+ * CLI options derived from command-line flags.
+ */
+type CLIOptions = {
+  /**
+   * Path to `kubb.config.js`.
+   */
+  config?: string;
+  /**
+   * Enable watch mode for input files.
+   */
+  watch?: boolean;
+  /**
+   * Logging verbosity for CLI usage.
+   *
+   * - `silent`: hide non-essential logs
+   * - `info`: show general logs (non-plugin-related)
+   * - `debug`: include detailed plugin lifecycle logs
+   * @default 'silent'
+   */
+  logLevel?: 'silent' | 'info' | 'debug';
+};
+/**
+ * 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
+ *
+ * @example
+ * export default defineConfig(({ logLevel }) => ({
+ *   root: 'src',
+ *   plugins: [myPlugin()],
+ * }))
+ * @deprecated as of Kubb v5, @kubb/core will not expose `defineConfig` anymore. use the `kubb` package instead
+ */
+declare function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config;
+declare function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config;
+//#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 use ast package instead
+ */
+type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
+/**
+ * @deprecated use ast package instead
+ */
+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/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;
+};
+/**
+ * Generates `index.ts` barrel files for all directories under `root/output.path`.
+ *
+ * - Returns an empty array when `type` is falsy or `'propagate'`.
+ * - Skips generation when the output path itself ends with `index` (already a barrel).
+ * - 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.
+ */
+declare function getBarrelFiles(files: Array<ResolvedFile>, {
+  type,
+  meta,
+  root,
+  output
+}: AddIndexesProps): Promise<Array<File>>;
+//#endregion
 //#region src/types.d.ts
 declare global {
   namespace Kubb {
@@ -548,12 +854,43 @@ declare global {
  * ...
  * })
  */
-type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins'> & {
+type UserConfig<TInput = Input> = Omit<Config<TInput>, 'root' | 'plugins' | 'parsers' | 'adapter'> & {
   /**
    * The project root directory, which can be either an absolute path or a path relative to the location of your `kubb.config.ts` file.
    * @default process.cwd()
    */
   root?: string;
+  /**
+   * An array of parsers used to convert generated files to strings.
+   * Each parser handles specific file extensions (e.g. `.ts`, `.tsx`).
+   *
+   * A catch-all fallback parser is always appended last for any unhandled extension.
+   *
+   * When omitted, `parserTs` from `@kubb/parser-ts` is used automatically as the
+   * default (requires `@kubb/parser-ts` to be installed as an optional dependency).
+   * @default [parserTs] — from `@kubb/parser-ts`
+   * @example
+   * ```ts
+   * import { parserTs, tsxParser } from '@kubb/parser-ts'
+   * export default defineConfig({
+   *   parsers: [parserTs, tsxParser],
+   * })
+   * ```
+   */
+  parsers?: Array<Parser>;
+  /**
+   * Adapter that converts the input file into a `@kubb/ast` `RootNode` — the universal
+   * intermediate representation consumed by all Kubb plugins.
+   *
+   * When omitted, `adapterOas()` from `@kubb/adapter-oas` is used automatically as the
+   * default (requires `@kubb/adapter-oas` to be installed as an optional dependency).
+   *
+   * - Use `@kubb/adapter-oas` for OpenAPI / Swagger (default).
+   * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
+   *
+   * @default adapterOas() — from `@kubb/adapter-oas`
+   */
+  adapter?: Adapter;
   /**
    * An array of Kubb plugins used for generation. Each plugin may have additional configurable options (defined within the plugin itself). If a plugin relies on another plugin, an error will occur if the required dependency is missing. Refer to “pre” for more details.
    */
@@ -571,7 +908,7 @@ type InputData = {
    */
   data: string | unknown;
 };
-type Input = InputPath | InputData | Array<InputPath>;
+type Input = InputPath | InputData;
 /**
  * The raw source passed to an adapter's `parse` function.
  * Mirrors the shape of `Config['input']` with paths already resolved to absolute.
@@ -639,7 +976,7 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
    */
   parse: (source: AdapterSource) => PossiblePromise<RootNode>;
   /**
-   * Extracts `FabricFile.Import` entries needed by a `SchemaNode` tree.
+   * Extracts `KubbFile.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
@@ -648,7 +985,7 @@ type Adapter<TOptions extends AdapterFactoryOptions = AdapterFactoryOptions> = {
   getImports: (node: SchemaNode, resolve: (schemaName: string) => {
     name: string;
     path: string;
-  }) => Array<FabricFile.Import>;
+  }) => Array<Import>;
 };
 type BarrelType = 'all' | 'named' | 'propagate';
 type DevtoolsOptions = {
@@ -672,24 +1009,41 @@ type Config<TInput = Input> = {
    * @default process.cwd()
    */
   root: string;
+  /**
+   * An array of parsers used to convert generated files to strings.
+   * Each parser handles specific file extensions (e.g. `.ts`, `.tsx`).
+   *
+   * A catch-all fallback parser is always appended last for any unhandled extension.
+   *
+   * When omitted, `parserTs` from `@kubb/parser-ts` is used automatically as the
+   * default (requires `@kubb/parser-ts` to be installed as an optional dependency).
+   * @default [parserTs] — from `@kubb/parser-ts`
+   * @example
+   * ```ts
+   * import { parserTs, tsxParser } from '@kubb/parser-ts'
+   * export default defineConfig({
+   *   parsers: [parserTs, tsxParser],
+   * })
+   * ```
+   */
+  parsers: Array<Parser>;
   /**
    * Adapter that converts the input file into a `@kubb/ast` `RootNode` — the universal
    * intermediate representation consumed by all Kubb plugins.
    *
-   * - Omit (or pass `undefined`) to use the built-in OpenAPI/Swagger adapter.
-   * - Use `@kubb/adapter-oas` for explicit OpenAPI configuration (validate, contentType, …).
+   * - Use `@kubb/adapter-oas` for OpenAPI / Swagger.
    * - Use `@kubb/adapter-drizzle` or `@kubb/adapter-asyncapi` for other formats.
    *
    * @example
    * ```ts
-   * import { drizzleAdapter } from '@kubb/adapter-drizzle'
+   * import { adapterOas } from '@kubb/adapter-oas'
    * export default defineConfig({
-   *   adapter: drizzleAdapter(),
-   *   input: { path: './src/schema.ts' },
+   *   adapter: adapterOas(),
+   *   input: { path: './petStore.yaml' },
    * })
    * ```
    */
-  adapter?: Adapter;
+  adapter: Adapter;
   /**
    * You can use either `input.path` or `input.data`, depending on your specific needs.
    */
@@ -747,7 +1101,7 @@ type Config<TInput = Input> = {
      * Overrides the extension for generated imports and exports. By default, each plugin adds an extension.
      * @default { '.ts': '.ts'}
      */
-    extension?: Record<FabricFile.Extname, FabricFile.Extname | ''>;
+    extension?: Record<Extname, 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'
@@ -839,8 +1193,8 @@ 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): FabricFile.Path;
-  resolveFile(params: ResolverFileParams, context: ResolverContext): FabricFile.File;
+  resolvePath(params: ResolverPathParams, context: ResolverContext): Path;
+  resolveFile(params: ResolverFileParams, context: ResolverContext): File;
   resolveBanner(node: RootNode | null, context: ResolveBannerContext): string | undefined;
   resolveFooter(node: RootNode | null, context: ResolveBannerContext): string | undefined;
 };
@@ -959,15 +1313,15 @@ type UnknownUserPlugin = UserPlugin<PluginFactoryOptions<string, object, object,
 /**
  * Handler for a single schema node. Used by the `schema` hook on a plugin.
  */
-type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+type SchemaHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: SchemaNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
 /**
  * Handler for a single operation node. Used by the `operation` hook on a plugin.
  */
-type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+type OperationHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, node: OperationNode, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
 /**
  * Handler for all collected operation nodes. Used by the `operations` hook on a plugin.
  */
-type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<FabricFile.File> | void>;
+type OperationsHook<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = (this: GeneratorContext<TOptions>, nodes: Array<OperationNode>, options: TOptions['resolvedOptions']) => PossiblePromise<FabricReactNode | Array<File> | void>;
 type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   /**
    * Unique name used for the plugin
@@ -1021,7 +1375,7 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   buildEnd: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
    * Called for each schema node during the AST walk.
-   * Return a React element, an array of `FabricFile.File`, or `void` for manual handling.
+   * Return a React element, an array of `KubbFile.File`, or `void` for manual handling.
    * Nodes matching `exclude`/`include` filters are skipped automatically.
    *
    * For multiple generators, use `composeGenerators` inside the plugin factory.
@@ -1029,7 +1383,7 @@ type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   schema?: SchemaHook<TOptions>;
   /**
    * Called for each operation node during the AST walk.
-   * Return a React element, an array of `FabricFile.File`, or `void` for manual handling.
+   * Return a React element, an array of `KubbFile.File`, or `void` for manual handling.
    *
    * For multiple generators, use `composeGenerators` inside the plugin factory.
    */
@@ -1062,7 +1416,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
   buildEnd?: (this: PluginContext<TOptions>) => PossiblePromise<void>;
   /**
    * Called for each schema node during the AST walk.
-   * Return a React element (`<File>...</File>`), an array of `FabricFile.File` objects,
+   * Return a React element (`<File>...</File>`), an array of `KubbFile.File` objects,
    * or `void` to handle file writing manually via `this.upsertFile`.
    * Nodes matching `exclude` / `include` filters are skipped automatically.
    *
@@ -1071,7 +1425,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
   schema?: SchemaHook<TOptions>;
   /**
    * Called for each operation node during the AST walk.
-   * Return a React element (`<File>...</File>`), an array of `FabricFile.File` objects,
+   * Return a React element (`<File>...</File>`), an array of `KubbFile.File` objects,
    * or `void` to handle file writing manually via `this.upsertFile`.
    *
    * For multiple generators, use `composeGenerators` inside the plugin factory.
@@ -1091,7 +1445,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    * @deprecated this will be replaced by resolvers
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: FabricFile.BaseName, mode?: FabricFile.Mode, options?: TOptions['resolvePathOptions']) => FabricFile.Path;
+  resolvePath?: (this: PluginContext<TOptions>, baseName: BaseName, mode?: Mode, options?: TOptions['resolvePathOptions']) => Path;
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -1105,8 +1459,8 @@ type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
 type ResolvePathParams<TOptions = object> = {
   pluginName?: string;
-  baseName: FabricFile.BaseName;
-  mode?: FabricFile.Mode;
+  baseName: BaseName;
+  mode?: Mode;
   /**
    * Options to be passed to 'resolvePath' 3th parameter
    */
@@ -1140,7 +1494,7 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    */
   getMode: (output: {
     path: string;
-  }) => FabricFile.Mode;
+  }) => Mode;
   driver: PluginDriver;
   /**
    * Get a plugin by name. Returns the plugin typed via `Kubb.PluginRegistry` when
@@ -1157,11 +1511,11 @@ type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
   /**
    * Only add when the file does not exist yet
    */
-  addFile: (...file: Array<FabricFile.File>) => Promise<void>;
+  addFile: (...file: Array<File>) => Promise<void>;
   /**
    * merging multiple sources into the same output file
    */
-  upsertFile: (...file: Array<FabricFile.File>) => Promise<void>;
+  upsertFile: (...file: Array<File>) => Promise<void>;
   /**
    * @deprecated use this.warn, this.error, this.info instead
    */
@@ -1394,8 +1748,8 @@ type ResolvePathOptions = {
  * ```
  */
 type ResolverPathParams = {
-  baseName: FabricFile.BaseName;
-  pathMode?: FabricFile.Mode;
+  baseName: BaseName;
+  pathMode?: Mode;
   /**
    * Tag value used when `group.type === 'tag'`.
    */
@@ -1446,7 +1800,7 @@ type ResolverContext = {
  */
 type ResolverFileParams = {
   name: string;
-  extname: FabricFile.Extname;
+  extname: Extname;
   /**
    * Tag value used when `group.type === 'tag'`.
    */
@@ -1502,8 +1856,8 @@ type Options = {
  */
 type GetFileOptions<TOptions = object> = {
   name: string;
-  mode?: FabricFile.Mode;
-  extname: FabricFile.Extname;
+  mode?: Mode;
+  extname: Extname;
   pluginName: string;
   options?: TOptions;
 };
@@ -1516,7 +1870,7 @@ type GetFileOptions<TOptions = object> = {
  * getMode('src/gen/types')     // 'split'
  * ```
  */
-declare function getMode(fileOrFolder: string | undefined | null): FabricFile.Mode;
+declare function getMode(fileOrFolder: string | undefined | null): Mode;
 declare class PluginDriver {
   #private;
   readonly config: Config;
@@ -1540,13 +1894,13 @@ declare class PluginDriver {
     extname,
     pluginName,
     options
-  }: GetFileOptions<TOptions>): FabricFile.File<{
+  }: GetFileOptions<TOptions>): File<{
     pluginName: string;
   }>;
   /**
    * @deprecated use resolvers context instead
    */
-  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => FabricFile.Path;
+  resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => Path;
   /**
    * @deprecated use resolvers context instead
    */
@@ -1628,5 +1982,5 @@ declare class PluginDriver {
   requirePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(pluginName: string): Plugin<TOptions>;
 }
 //#endregion
-export { defineGenerator as $, Preset as A, Resolver as B, Plugin as C, PluginLifecycleHooks as D, PluginLifecycle as E, ResolveBannerContext as F, UserConfig as G, ResolverFileParams as H, ResolveNameParams as I, UserPlugin as J, UserGroup as K, ResolveOptionsContext as L, Printer$1 as M, PrinterFactoryOptions as N, PluginParameter as O, PrinterPartial as P, Generator as Q, ResolvePathOptions as R, Override as S, PluginFactoryOptions as T, ResolverPathParams as U, ResolverContext as V, SchemaHook as W, UserResolver as X, UserPluginWithLifeCycle as Y, KubbEvents as Z, LoggerContext as _, AdapterSource as a, logLevel as at, OperationsHook as b, Config as c, GeneratorContext as d, mergeGenerators as et, Group as f, Logger as g, InputPath as h, AdapterFactoryOptions as i, linters as it, Presets as j, PluginWithLifeCycle as k, DevtoolsOptions as l, InputData as m, getMode as n, createStorage as nt, BarrelType as o, PossiblePromise as ot, Include as p, UserLogger as q, Adapter as r, formatters as rt, CompatibilityPreset as s, AsyncEventEmitter as st, PluginDriver as t, Storage as tt, Exclude as u, LoggerOptions as v, PluginContext as w, Output as x, OperationHook as y, ResolvePathParams as z };
-//# sourceMappingURL=PluginDriver-D110FoJ-.d.ts.map
+export { FunctionParams as $, Preset as A, Resolver as B, Plugin as C, PluginLifecycleHooks as D, PluginLifecycle as E, ResolveBannerContext as F, UserConfig as G, ResolverFileParams as H, ResolveNameParams as I, UserPlugin as J, UserGroup as K, ResolveOptionsContext as L, Printer$1 as M, PrinterFactoryOptions as N, PluginParameter as O, PrinterPartial as P, getBarrelFiles as Q, ResolvePathOptions as R, Override as S, PluginFactoryOptions as T, ResolverPathParams as U, ResolverContext as V, SchemaHook as W, UserResolver as X, UserPluginWithLifeCycle as Y, FileMetaBase as Z, LoggerContext as _, KubbFile_d_exports as _t, AdapterSource as a, Parser as at, OperationsHook as b, ResolvedFile as bt, Config as c, Generator as ct, GeneratorContext as d, Storage as dt, FunctionParamsAST as et, Group as f, createStorage as ft, Logger as g, File as gt, InputPath as h, logLevel as ht, AdapterFactoryOptions as i, KubbEvents as it, Presets as j, PluginWithLifeCycle as k, DevtoolsOptions as l, defineGenerator as lt, InputData as m, linters as mt, getMode as n, ConfigInput as nt, BarrelType as o, UserParser as ot, Include as p, formatters as pt, UserLogger as q, Adapter as r, defineConfig as rt, CompatibilityPreset as s, defineParser as st, PluginDriver as t, CLIOptions as tt, Exclude as u, mergeGenerators as ut, LoggerOptions as v, Mode as vt, PluginContext as w, Output as x, AsyncEventEmitter as xt, OperationHook as y, Path as yt, ResolvePathParams as z };
+//# sourceMappingURL=PluginDriver-D0dY_hpJ.d.ts.map