@kubb/core 5.0.0-beta.98 → 5.0.0

package/dist/{types-CK6CfipY.d.ts → types-Ba5Mo-G8.d.ts}

@@ -152,10 +152,30 @@ declare const diagnosticCode: {
    * The file or URL set as `input` could not be read.
    */
   readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
+  /**
+   * A URL set as `input` (or referenced by a `$ref`) answered with a 4xx or 5xx status
+   * instead of the document.
+   */
+  readonly inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED";
+  /**
+   * A URL set as `input` (or referenced by a `$ref`) never answered, so the request failed
+   * before a status was returned.
+   */
+  readonly inputUnreachable: "KUBB_INPUT_UNREACHABLE";
   /**
    * An adapter was configured without an `input`.
    */
   readonly inputRequired: "KUBB_INPUT_REQUIRED";
+  /**
+   * `input` uses the v4 `{ path }` / `{ data }` wrapper, which v5 reads as a parsed
+   * document instead of a pointer to one.
+   */
+  readonly legacyInput: "KUBB_LEGACY_INPUT";
+  /**
+   * The parsed `input` carries no `openapi` or `swagger` version, so it is not a
+   * document the adapter can read.
+   */
+  readonly invalidDocument: "KUBB_INVALID_DOCUMENT";
   /**
    * A `$ref` (or equivalent reference) could not be resolved in the source document.
    */
@@ -498,7 +518,11 @@ declare class Diagnostics {
   static code: {
     readonly unknown: "KUBB_UNKNOWN";
     readonly inputNotFound: "KUBB_INPUT_NOT_FOUND";
+    readonly inputRequestFailed: "KUBB_INPUT_REQUEST_FAILED";
+    readonly inputUnreachable: "KUBB_INPUT_UNREACHABLE";
     readonly inputRequired: "KUBB_INPUT_REQUIRED";
+    readonly legacyInput: "KUBB_LEGACY_INPUT";
+    readonly invalidDocument: "KUBB_INVALID_DOCUMENT";
     readonly refNotFound: "KUBB_REF_NOT_FOUND";
     readonly invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE";
     readonly pluginNotFound: "KUBB_PLUGIN_NOT_FOUND";
@@ -766,6 +790,9 @@ declare function createReporter<T = void>(reporter: UserReporter<T>): Reporter;
  * Backend that persists generated files. Kubb ships with `fsStorage` (writes
  * to disk) and `memoryStorage` (keeps everything in RAM). Implement this
  * interface to write somewhere else, such as S3 or a database.
+ *
+ * Method names follow Node's filesystem vocabulary, so `readItem` reads like
+ * `readFile` and `writeItem` like `writeFile`.
  */
 type Storage = {
   /**
@@ -775,16 +802,16 @@ type Storage = {
   /**
    * Returns `true` when an entry for `key` exists.
    */
-  hasItem(key: string): Promise<boolean>;
+  existsItem(key: string): Promise<boolean>;
   /**
    * Reads the stored string. Returns `null` when the key is missing.
    */
-  getItem(key: string): Promise<string | null>;
+  readItem(key: string): Promise<string | null>;
   /**
    * Stores `value` under `key`, creating any required structure (directories,
    * buckets, ...).
    */
-  setItem(key: string, value: string): Promise<void>;
+  writeItem(key: string, value: string): Promise<void>;
   /**
    * Deletes the entry for `key`. No-op when the key does not exist.
    */
@@ -792,15 +819,15 @@ type Storage = {
   /**
    * Returns every key. Pass `base` to filter to keys starting with that prefix.
    */
-  getKeys(base?: string): Promise<Array<string>>;
+  readKeys(base?: string): Promise<Array<string>>;
   /**
    * Removes stored entries. Pass `base` to scope the wipe to a key prefix.
    *
    * Omitting `base` is implementation-defined: in-memory stores wipe every
    * entry, while filesystem-backed stores treat a missing `base` as a no-op so
-   * a bare `clear()` can never delete outside a known output directory.
+   * a bare `empty()` can never delete outside a known output directory.
    */
-  clear(base?: string): Promise<void>;
+  empty(base?: string): Promise<void>;
 };
 /**
  * Defines a custom storage backend. The builder receives user options and
@@ -817,23 +844,23 @@ type Storage = {
  *
  *   return {
  *     name: 'memory',
- *     async hasItem(key) {
+ *     async existsItem(key) {
  *       return store.has(key)
  *     },
- *     async getItem(key) {
+ *     async readItem(key) {
  *       return store.get(key) ?? null
  *     },
- *     async setItem(key, value) {
+ *     async writeItem(key, value) {
  *       store.set(key, value)
  *     },
  *     async removeItem(key) {
  *       store.delete(key)
  *     },
- *     async getKeys(base) {
+ *     async readKeys(base) {
  *       const keys = [...store.keys()]
  *       return base ? keys.filter((k) => k.startsWith(base)) : keys
  *     },
- *     async clear(base) {
+ *     async empty(base) {
  *       if (!base) store.clear()
  *     },
  *   }
@@ -1207,6 +1234,10 @@ declare class Resolver {
    * schemas (`targetName`) import the emitted name. Names and paths go through the top-level
    * `name` and `file`, so import entries follow the plugin's conventions, and a per-call
    * `name` override wins over both.
+   *
+   * The subtree scan runs through `collectImportedRefNames`, which memoizes by node identity, so a
+   * schema shared across the ts, zod, and faker plugins is walked once and every plugin's resolver
+   * reads the same ref set instead of re-scanning it per plugin.
    */
   imports(options: ResolveImportsOptions): Array<ImportNode>;
   /**
@@ -1240,8 +1271,8 @@ type PluginName = LiteralUnion<keyof Kubb.PluginRegistry>;
 type ResolvePluginOptions<TName> = TName extends keyof Kubb.PluginRegistry ? Kubb.PluginRegistry[TName] : PluginFactoryOptions;
 /**
  * How a plugin consolidates its generated code into files.
- * - `'directory'` writes one file per operation or schema under `path`.
  * - `'file'` writes everything into a single file.
+ * - `'directory'` writes one file per operation or schema under `path`.
  */
 type OutputMode = 'directory' | 'file';
 /**
@@ -1257,10 +1288,10 @@ type Output = {
   path: string;
   /**
    * How generated code is consolidated into files.
-   * - `'directory'` writes one file per operation or schema under `path`.
    * - `'file'` writes everything into a single file. The `path` must include the file extension.
+   * - `'directory'` writes one file per operation or schema under `path`.
    *
-   * @default 'directory'
+   * Defaults to `'file'` when `path` carries an extension and `'directory'` when it does not.
    */
   mode?: OutputMode;
   /**
@@ -1303,9 +1334,13 @@ type Group = {
 };
 /**
  * Couples `output.mode` with the plugin's `group` option at the type level.
- * - `mode: 'file'` forbids `group` (a single file has nothing to group).
- * - `mode: 'directory'` (or no mode) allows an optional `group` to organize
- *   files into per-group subdirectories.
+ * - An explicit `mode: 'file'` forbids `group` (a single file has nothing to group).
+ * - Omitting `mode`, or setting it to `'directory'`, allows an optional `group`.
+ *
+ * `mode` is normally inferred from `output.path` (an extension means `'file'`, anything
+ * else `'directory'`), so `group` rarely needs `mode` spelled out alongside it. Set
+ * `mode: 'directory'` explicitly only to override that inference, such as a directory
+ * name that carries a dot (`path: 'clients.v2'`).
  *
  * Intersect into a plugin's `Options` type instead of declaring `output` and
  * `group` directly, since `mode` lives inside `output` while `group` is its sibling.
@@ -1324,7 +1359,7 @@ type OutputOptions<TOutput extends Output = Output> = {
   };
   group?: Group;
 } | {
-  output: TOutput & {
+  output?: TOutput & {
     mode: 'file';
   };
   group?: never;
@@ -1682,6 +1717,39 @@ type Parser<TMeta extends object = object, TNode = unknown> = {
  */
 declare function defineParser<TOptions extends object = object, TMeta extends object = object, TNode = unknown>(factory: (options: TOptions) => Parser<TMeta, TNode>): (options?: TOptions) => Parser<TMeta, TNode>;
 //#endregion
+//#region src/outputManifest.d.ts
+/**
+ * Remembers what the output passes did to each generated file, so the next run can tell "the
+ * formatter already turned this exact source into what is stored" apart from a real change.
+ * Without it the storage compares Kubb's bytes against the formatter's, never matches, and
+ * rewrites the whole output tree on every build.
+ */
+type OutputManifest = {
+  /**
+   * `true` when `source` is known to come out of the output passes as exactly the content stored,
+   * meaning the write can be skipped.
+   */
+  isUpToDate(options: {
+    key: string;
+    source: string;
+    disk: string;
+  }): boolean;
+  /**
+   * Records the source Kubb wrote for `key`, marking it as the only kind of file the output passes
+   * can have changed and so the only kind `commit` has to re-read.
+   */
+  track(options: {
+    key: string;
+    source: string;
+  }): void;
+  /**
+   * Re-reads the files written this run and persists their source/output pairs on top of what is
+   * stored. Nothing is pruned: a run generating a different set of files, or writing to a different
+   * storage in the same root, must not evict what another run recorded.
+   */
+  commit(): Promise<void>;
+};
+//#endregion
 //#region src/FileManager.d.ts
 /**
  * Hooks fired around a `FileManager#write` batch: `start` before it, `update` per file, `end` after.
@@ -1702,6 +1770,11 @@ type ParseOptions = {
 };
 type WriteOptions = ParseOptions & {
   storage: Storage;
+  /**
+   * Consulted before each write so a file the output passes already normalized is recognized as
+   * unchanged. Omitted when no formatter, linter, or `postGenerate` step is configured.
+   */
+  manifest?: OutputManifest;
 };
 /**
  * In-memory file store for generated files, and the writer that turns them into source
@@ -1738,15 +1811,25 @@ declare class FileManager {
    */
   parse(file: FileNode, { parsers }?: ParseOptions): Promise<string>;
   /**
-   * Converts and writes every file at once, letting `storage.setItem` decide how much of
-   * that runs concurrently.
+   * Parses and writes every file through a bounded pool of workers. A small spec runs all its files
+   * at once; a spec with thousands of files keeps at most {@link FILE_CONCURRENCY} parsed sources in
+   * memory rather than holding every source, while still overlapping each file's write with the
+   * next file's parse. Each `update` carries the file's input position, so a consumer can present
+   * the files in generation order even though they finish in whatever order they parse.
+   *
+   * A file the storage already holds is skipped, so a rebuild that generates identical output
+   * writes nothing and leaves every mtime where it was.
    */
-  write(files: Array<FileNode>, { storage, parsers }: WriteOptions): Promise<void>;
+  write(files: Array<FileNode>, { storage, parsers, manifest }: WriteOptions): Promise<void>;
 }
 //#endregion
 //#region src/KubbDriver.d.ts
 type Options = {
   hooks: Hookable<KubbHooks>;
+  /**
+   * Passed to `fileManager.write` so files the output passes already normalized are left alone.
+   */
+  manifest?: OutputManifest;
 };
 type RequirePluginContext = {
   /**
@@ -1788,15 +1871,13 @@ declare class KubbDriver {
    */
   setupHooks(): Promise<void>;
   /**
-   * Registers a generator for the given plugin on the shared hook emitter.
+   * Appends a generator to its owning plugin so the generate loop can call it directly.
    *
-   * The generator's `schema`, `operation`, and `operations` methods are registered as
-   * listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
-   * respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
-   * so that generators from different plugins do not cross-fire.
-   *
-   * The renderer comes from `generator.renderer`. Set `generator.renderer = null` (or leave it
-   * unset) to opt out of rendering.
+   * The generator's `schema`, `operation`, and `operations` methods run per node during the AST
+   * walk in `#runGenerators`, and their result is routed through `dispatch`. Because a generator is
+   * bound to a plugin, generators from different plugins never cross-fire without a name check. The
+   * renderer comes from `generator.renderer`; set it to `null` (or leave it unset) to opt out of
+   * rendering.
    *
    * Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
    */
@@ -1805,7 +1886,7 @@ declare class KubbDriver {
    * Returns `true` when at least one generator was registered for the given plugin
    * via `addGenerator()` in `kubb:plugin:setup`.
    *
-   * Used by the build loop to decide whether to walk the AST and emit generator hooks
+   * Used by the build loop to decide whether to walk the AST and run the generators
    * for a plugin.
    */
   hasHookGenerators(pluginName: string): boolean;
@@ -1843,19 +1924,17 @@ declare class KubbDriver {
   dispose(): void;
   [Symbol.dispose](): void;
   /**
-   * Merges `partial` with the plugin's default resolver and stores the result.
-   * Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
-   * get the up-to-date resolver without going through `getResolver()`.
+   * Merges `partial` onto a fresh default resolver and stores the result on `plugin.resolver`,
+   * which is the single source `getResolver` and `getPlugin(name).resolver` both read.
    */
   setPluginResolver(pluginName: string, partial: ResolverPatch | Resolver): void;
   /**
-   * Returns the resolver for the given plugin.
-   *
-   * Resolution order: resolver set via `setPluginResolver` → lazily created default
-   * resolver (identity name, no path transforms).
+   * Returns the resolver for the given plugin. It reads `plugin.resolver` (seeded with the default
+   * at registration and replaced by `setPluginResolver`), falling back to a fresh default for a
+   * name that is not a registered plugin.
    */
   getResolver<TName extends PluginName>(pluginName: TName): ResolvePluginOptions<TName>['resolver'];
-  getContext<TOptions extends PluginFactoryOptions>(plugin: NormalizedPlugin<TOptions>): Omit<GeneratorContext<TOptions>, 'options'>;
+  getContext<TOptions extends PluginFactoryOptions>(plugin: NormalizedPlugin<TOptions>): Omit<GeneratorContext<TOptions>, 'options' | 'cache'>;
   getPlugin<TName extends PluginName>(pluginName: TName): Plugin<ResolvePluginOptions<TName>> | undefined;
   /**
    * Like `getPlugin` but throws a descriptive error when the plugin is not found.
@@ -1863,6 +1942,38 @@ declare class KubbDriver {
   requirePlugin<TName extends PluginName>(pluginName: TName, context?: RequirePluginContext): Plugin<ResolvePluginOptions<TName>>;
 }
 //#endregion
+//#region src/nodeCache.d.ts
+/**
+ * Per-node memo shared by every plugin that generates from the same schema or operation node in
+ * one generate pass. The driver creates one `NodeCache` per node during the walk and hands the
+ * same instance to each plugin's generator context, so work derived purely from the node (its
+ * resolved name, imports, parameters) is computed by the first plugin that needs it and reused by
+ * the rest instead of being recomputed per plugin.
+ *
+ * Keys are namespaced by convention (`'plugin-ts:imports'`) so two plugins caching different
+ * derivations of the same node never collide.
+ *
+ * @example Fill on first read, reuse afterwards
+ * ```ts
+ * const imports = ctx.cache.ensureItem('plugin-ts:imports', () => ctx.resolver.imports({ node, root, output }))
+ * ```
+ */
+type NodeCache = {
+  /**
+   * Returns the value stored under `key`, or `undefined` when nothing is stored yet.
+   */
+  readItem<TValue>(key: string): TValue | undefined;
+  /**
+   * Stores `value` under `key`, overwriting any previous value, and returns it.
+   */
+  writeItem<TValue>(key: string, value: TValue): TValue;
+  /**
+   * Returns the value stored under `key`, computing and storing it with `factory` on the first
+   * call. Later calls with the same key return the stored value without running `factory` again.
+   */
+  ensureItem<TValue>(key: string, factory: () => TValue): TValue;
+};
+//#endregion
 //#region src/defineGenerator.d.ts
 /**
  * Context passed to a generator's `schema`, `operation`, and `operations` methods.
@@ -1957,6 +2068,13 @@ type GeneratorContext<TOptions extends PluginFactoryOptions = PluginFactoryOptio
    * Resolved options after exclude/include/override filtering.
    */
   options: TOptions['resolvedOptions'];
+  /**
+   * Cache scoped to the node being generated, shared by every plugin that generates from that
+   * same node in the current pass. Use it to compute node-derived work (resolved names, imports,
+   * parameters) once and let the other plugins reuse it. For the `operations` batch call, where
+   * there is no single node, the cache is a fresh scratch scope for that call.
+   */
+  cache: NodeCache;
 };
 /**
  * Declares a named generator unit that walks the AST and emits files.
@@ -2008,6 +2126,24 @@ type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TEl
    * ```
    */
   renderer?: RendererFactory<TElement> | null;
+  /**
+   * Predicate checked before `schema` or `operation` runs for a node, mirroring `Macro['match']`
+   * in `@kubb/ast`. Returning `false` skips the call for that node entirely, with no context work
+   * beyond what the driver already builds per node and no render call, instead of the generator
+   * itself being invoked and returning early. Omit it to run for every node, the default when
+   * unset.
+   *
+   * Does not gate `operations`, which already runs once per plugin on the full batch rather than
+   * per node.
+   *
+   * @example Only match GET operations
+   * ```ts
+   * match(node, ctx) {
+   *   return ast.isHttpOperationNode(node) && node.method.toLowerCase() === 'get'
+   * }
+   * ```
+   */
+  match?: (node: SchemaNode | OperationNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<boolean>;
   /**
    * Called for each schema node in the AST walk.
    * `ctx` carries the plugin context with `adapter` and `meta` (document metadata),
@@ -2061,6 +2197,37 @@ declare function defineGenerator<TOptions extends PluginFactoryOptions = PluginF
 type CreateKubbOptions = {
   hooks?: Hookable<KubbHooks>;
 };
+/**
+ * Host hooks for a single {@link Kubb.generate} call. All optional. Progress narration rides the
+ * `kubb:*` lifecycle hooks on `.hooks`, so hosts subscribe there rather than pass a callback.
+ */
+type GenerateOptions = {
+  /**
+   * Format, lint, and run `postGenerate` over the generated output after an error-free build, and
+   * return the diagnostics they emitted. CLI-only.
+   */
+  processOutput?: (context: {
+    config: Config;
+    outputPath: string;
+  }) => Promise<Array<Diagnostic>>;
+};
+/**
+ * What a {@link Kubb.generate} call produced, for the host to map onto its own result shape.
+ */
+type GenerateResult = {
+  /**
+   * `true` when the build and every output pass completed without an error-level diagnostic.
+   */
+  success: boolean;
+  /**
+   * All files generated during the build.
+   */
+  files: Array<FileNode>;
+  /**
+   * Build diagnostics plus any collected from the output passes.
+   */
+  diagnostics: Array<Diagnostic>;
+};
 /**
  * Kubb code-generation instance bound to a single config entry. Resolves the user
  * config in the constructor, so `config` is available right away, and shares `hooks`,
@@ -2100,6 +2267,19 @@ declare class Kubb$1 {
    * plugin errors, so callers stay in control of how failures surface.
    */
   safeBuild(): Promise<BuildOutput>;
+  /**
+   * Run one build and its output passes end to end, emitting the surrounding `kubb:generation:*`
+   * hooks. Never throws on a build error: the outcome comes back in {@link GenerateResult} so the
+   * host decides how failures surface. Telemetry and progress narration stay with the host, which
+   * reads the result and subscribes to the `kubb:*` hooks.
+   *
+   * @example
+   * ```ts
+   * const result = await createKubb(config, { hooks }).generate()
+   * if (!result.success) process.exitCode = 1
+   * ```
+   */
+  generate(options?: GenerateOptions): Promise<GenerateResult>;
   dispose(): void;
   [Symbol.dispose](): void;
 }
@@ -2483,6 +2663,8 @@ interface KubbHooks {
   'kubb:lifecycle:end': [];
   'kubb:generation:start': [ctx: KubbGenerationStartContext];
   'kubb:generation:end': [ctx: KubbGenerationEndContext];
+  'kubb:setup:start': [];
+  'kubb:setup:end': [];
   'kubb:format:start': [];
   'kubb:format:end': [];
   'kubb:lint:start': [];
@@ -2587,12 +2769,12 @@ type KubbGenerationEndContext = {
    * Reads go directly to `config.storage`, nothing extra is held in memory.
    *
    * @example Read a generated file
-   * `const code = await storage.getItem('/src/gen/pet.ts')`
+   * `const code = await storage.readItem('/src/gen/pet.ts')`
    *
    * @example Walk every generated file
    * ```ts
-   * for (const path of await storage.getKeys()) {
-   *   const code = await storage.getItem(path)
+   * for (const path of await storage.readKeys()) {
+   *   const code = await storage.readItem(path)
    * }
    * ```
    */
@@ -2681,10 +2863,6 @@ type KubbFileProcessingUpdate = {
    * Completion percentage, `0` to `100`.
    */
   percentage: number;
-  /**
-   * Serialized file content, or `undefined` when the file produced no output.
-   */
-  source?: string;
   /**
    * The file that was just processed.
    */
@@ -2829,10 +3007,10 @@ type BuildOutput = {
    * Use `files` to list what this build produced.
    *
    * @example Read a generated file
-   * `const code = await buildOutput.storage.getItem('/src/gen/pet.ts')`
+   * `const code = await buildOutput.storage.readItem('/src/gen/pet.ts')`
    */
   storage: Storage;
 };
 //#endregion
-export { definePlugin as $, Generator as A, DiagnosticSeverity as At, Include as B, AdapterSource as Bt, KubbWarnContext as C, UserReporter as Ct, CreateKubbOptions as D, DiagnosticDoc as Dt, UserConfig as E, Diagnostic as Et, Parser as F, SerializedDiagnostic as Ft, Output as G, KubbPluginSetupContext as H, defineParser as I, UpdateDiagnostic as It, Override as J, OutputMode as K, Exclude$1 as L, Hookable as Lt, defineGenerator as M, PerformanceDiagnostic as Mt, KubbDriver as N, ProblemCode as Nt, Kubb$1 as O, DiagnosticKind as Ot, FileManagerHooks as P, ProblemDiagnostic as Pt, ResolvePluginOptions as Q, Filter as R, Adapter as Rt, KubbSuccessContext as S, ReporterName as St, PostGenerateCommand as T, logLevel as Tt, KubbPluginStartContext as U, KubbPluginEndContext as V, createAdapter as Vt, NormalizedPlugin as W, PluginFactoryOptions as X, Plugin as Y, PluginName as Z, KubbHookStartContext as _, Storage as _t, KubbBuildEndContext as a, ResolveOptionsContext as at, KubbLifecycleStartContext as b, Reporter as bt, KubbErrorContext as c, ResolverDefault as ct, KubbFilesProcessingStartContext as d, ResolverFilePathParams as dt, BannerMeta as et, KubbFilesProcessingUpdateContext as f, ResolverPatch as ft, KubbHookLineContext as g, createRenderer as gt, KubbHookEndContext as h, RendererFactory as ht, Input as i, ResolveImportsOptions as it, GeneratorContext as j, Diagnostics as jt, createKubb as k, DiagnosticLocation as kt, KubbFileProcessingUpdate as l, ResolverFile as lt, KubbGenerationStartContext as m, Renderer as mt, CLIOptions as n, ResolveBannerFile as nt, KubbBuildStartContext as o, ResolvePathOptions as ot, KubbGenerationEndContext as p, ResolverPathParams as pt, OutputOptions as q, Config as r, ResolveFileOptions as rt, KubbDiagnosticContext as s, Resolver as st, BuildOutput as t, ResolveBannerContext as tt, KubbFilesProcessingEndContext as u, ResolverFileParams as ut, KubbHooks as v, createStorage as vt, PossibleConfig as w, createReporter as wt, KubbPluginsEndContext as x, ReporterContext as xt, KubbInfoContext as y, GenerationResult as yt, Group as z, AdapterFactoryOptions as zt };
-//# sourceMappingURL=types-CK6CfipY.d.ts.map
+export { PluginFactoryOptions as $, Kubb$1 as A, DiagnosticDoc as At, Exclude$1 as B, Hookable as Bt, KubbWarnContext as C, Reporter as Ct, CreateKubbOptions as D, createReporter as Dt, UserConfig as E, UserReporter as Et, NodeCache as F, PerformanceDiagnostic as Ft, KubbPluginSetupContext as G, Group as H, AdapterFactoryOptions as Ht, KubbDriver as I, ProblemCode as It, Output as J, KubbPluginStartContext as K, FileManagerHooks as L, ProblemDiagnostic as Lt, Generator as M, DiagnosticLocation as Mt, GeneratorContext as N, DiagnosticSeverity as Nt, GenerateOptions as O, logLevel as Ot, defineGenerator as P, Diagnostics as Pt, Plugin as Q, Parser as R, SerializedDiagnostic as Rt, KubbSuccessContext as S, GenerationResult as St, PostGenerateCommand as T, ReporterName as Tt, Include as U, AdapterSource as Ut, Filter as V, Adapter as Vt, KubbPluginEndContext as W, createAdapter as Wt, OutputOptions as X, OutputMode as Y, Override as Z, KubbHookStartContext as _, Renderer as _t, KubbBuildEndContext as a, ResolveBannerFile as at, KubbLifecycleStartContext as b, Storage as bt, KubbErrorContext as c, ResolveOptionsContext as ct, KubbFilesProcessingStartContext as d, ResolverDefault as dt, PluginName as et, KubbFilesProcessingUpdateContext as f, ResolverFile as ft, KubbHookLineContext as g, ResolverPathParams as gt, KubbHookEndContext as h, ResolverPatch as ht, Input as i, ResolveBannerContext as it, createKubb as j, DiagnosticKind as jt, GenerateResult as k, Diagnostic as kt, KubbFileProcessingUpdate as l, ResolvePathOptions as lt, KubbGenerationStartContext as m, ResolverFilePathParams as mt, CLIOptions as n, definePlugin as nt, KubbBuildStartContext as o, ResolveFileOptions as ot, KubbGenerationEndContext as p, ResolverFileParams as pt, NormalizedPlugin as q, Config as r, BannerMeta as rt, KubbDiagnosticContext as s, ResolveImportsOptions as st, BuildOutput as t, ResolvePluginOptions as tt, KubbFilesProcessingEndContext as u, Resolver as ut, KubbHooks as v, RendererFactory as vt, PossibleConfig as w, ReporterContext as wt, KubbPluginsEndContext as x, createStorage as xt, KubbInfoContext as y, createRenderer as yt, defineParser as z, UpdateDiagnostic as zt };
+//# sourceMappingURL=types-Ba5Mo-G8.d.ts.map