@kubb/core 5.10.1 → 5.10.3

package/dist/index.d.cts

@@ -0,0 +1,620 @@
+import { $ as NodeCache, $t as ReporterPluginFiles, A as PluginFactory, At as KubbInfoContext, B as ResolveImportsOptions, Bt as RunHookOptions, C as NormalizedPlugin, Ct as KubbGenerationEndContext, D as Override, Dt as KubbHookLineContext, E as OutputOptions, Et as KubbHookEndContext, F as definePlugin, Ft as KubbWarnContext, G as ResolverFile, Gt as RendererFactory, H as ResolvePathOptions, Ht as KubbDriver, I as BannerMeta, It as PossibleConfig, J as ResolverPatch, Jt as createStorage, K as ResolverFileParams, Kt as createRenderer, L as ResolveBannerContext, Lt as PostGenerateCommand, M as PluginType, Mt as KubbMessageContext, N as ResolvePluginOptions, Nt as KubbPluginsEndContext, O as Plugin, Ot as KubbHookStartContext, P as assertPluginOption, Pt as KubbSuccessContext, Q as defineGenerator, Qt as ReporterName, R as ResolveBannerFile, Rt as UserConfig, S as KubbPluginStartContext, St as KubbFilesProcessingUpdateContext, T as OutputMode, Tt as KubbGenerationSummaryContext, U as Resolver, Ut as Hookable, V as ResolveOptionsContext, Vt as runHook, W as ResolverDefault, Wt as Renderer, X as Generator, Xt as Reporter, Y as ResolverPathParams, Yt as GenerationResult, Z as GeneratorContext, Zt as ReporterContext, _ as Filter, _t as KubbDiagnosticContext, a as AdapterSource, an as Parser, at as Diagnostics, b as KubbPluginEndContext, bt as KubbFilesProcessingEndContext, c as ExtensionDependency, cn as defineParser, ct as ProblemDiagnostic, d as ExtensionKind, dt as CLIOptions, en as UserReporter, et as Diagnostic, f as ExtensionMeta, ft as Config, g as Exclude, gt as KubbBuildStartContext, h as resolveMeta, ht as KubbBuildEndContext, i as AdapterFactoryOptions, in as SerializedDiagnostic, it as DiagnosticSeverity, j as PluginName, jt as KubbLifecycleStartContext, k as PluginDefinition, kt as KubbHooks, l as ExtensionDependencyRecord, lt as UpdateDiagnostic, m as defineExtension, mt as Input, n as AdapterDefinition, nn as logLevel, nt as DiagnosticKind, o as createAdapter, on as ParserDefinition, ot as PerformanceDiagnostic, p as checkCompatibility, pt as FilesContext, q as ResolverFilePathParams, qt as Storage, r as AdapterFactory, rn as DiagnosticFormatOptions, rt as DiagnosticLocation, s as ExtensionDependencies, sn as ParserFactory, st as ProblemCode, t as Adapter, tn as createReporter, tt as DiagnosticDoc, u as ExtensionFactory, ut as BuildOutput, v as Group, vt as KubbErrorContext, w as Output, wt as KubbGenerationStartContext, x as KubbPluginSetupContext, xt as KubbFilesProcessingStartContext, y as Include, yt as KubbFileProcessingUpdate, z as ResolveFileOptions, zt as HookResult } from "./createAdapter-B5kKMsWV.cjs";
+import { FileNode, Macro, UserFileNode } from "@kubb/ast";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/composables.d.ts
+/**
+ * Holds the setup context of the plugin whose `setup` or `kubb:plugin:setup` is running. `KubbDriver` sets it for each plugin.
+ *
+ * The store lives on `globalThis`, so the ESM and CommonJS builds of `@kubb/core` share one. A plugin that a
+ * CommonJS config loads would otherwise read an empty store and fail with `KUBB_NO_CONTEXT`.
+ */
+export declare const kubbContext: AsyncLocalStorage<KubbPluginSetupContext>;
+/**
+ * Returns the context of the plugin whose `kubb:plugin:setup` is running. It stays available after an `await`.
+ * Throws `KUBB_NO_CONTEXT` outside setup.
+ */
+export declare function useKubb<TFactory extends PluginType = PluginType>(): KubbPluginSetupContext<TFactory>;
+/**
+ * Returns the same context as {@link useKubb}, or `undefined` outside `setup` and `kubb:plugin:setup`.
+ */
+export declare function tryUseKubb<TFactory extends PluginType = PluginType>(): KubbPluginSetupContext<TFactory> | undefined;
+/**
+ * Registers generators on the plugin being set up, like `ctx.addGenerator`.
+ *
+ * @example
+ * `addGenerator(typeGenerator, enumGenerator)`
+ */
+export declare function addGenerator<TFactory extends PluginType = PluginType, TElement = unknown>(...generators: Array<Generator<TFactory, TElement>>): void;
+/**
+ * Sets the resolver of the plugin being set up, like `ctx.setResolver`.
+ */
+export declare function setResolver<TResolver extends Resolver = Resolver>(resolver: ResolverPatch<TResolver> | TResolver): void;
+/**
+ * Adds a macro to the plugin being set up, like `ctx.addMacro`.
+ */
+export declare function addMacro(macro: Macro): void;
+/**
+ * Replaces the macros of the plugin being set up, like `ctx.setMacros`.
+ */
+export declare function setMacros(macros: ReadonlyArray<Macro>): void;
+/**
+ * Adds a raw file to the build output, like `ctx.injectFile`.
+ */
+export declare function injectFile(file: UserFileNode): void;
+/**
+ * Returns the options the user passed to the plugin being set up, like `ctx.options`.
+ */
+export declare function useOptions<TFactory extends PluginType = PluginType>(): TFactory['options'];
+/**
+ * Sets the resolved options of the plugin being set up, like `ctx.setOptions`.
+ */
+export declare function setOptions<TFactory extends PluginType = PluginType>(options: TFactory['resolvedOptions']): void;
+/**
+ * Returns the resolved build configuration, like `ctx.config`.
+ */
+export declare function useConfig(): Config;
+/**
+ * Returns another plugin from the config, typed through `Kubb.PluginRegistry`, like `ctx.requirePlugin`.
+ */
+export declare function requirePlugin<TName extends PluginName>(name: TName): NormalizedPlugin<ResolvePluginOptions<TName>>;
+//#endregion
+//#region src/output/runOutputPasses.d.ts
+type RunOutputPassesOptions = {
+  config: Config;
+  /**
+   * Absolute directory the formatter and linter run over.
+   */
+  outputPath: string;
+  hooks: Hookable<KubbHooks>;
+  signal?: AbortSignal;
+};
+/**
+ * Runs `output.format`, `output.lint` and `output.postGenerate` over the generated output and
+ * returns the diagnostics they produced. Each failure is emitted through `Diagnostics.emit` and
+ * returned, so it reaches the summary, the reporters and the exit code; the passes keep going so
+ * one failing tool does not hide the next. `Kubb.generate()` runs this after an error-free build
+ * unless the host passes its own `processOutput`.
+ *
+ * @example
+ * ```ts
+ * const diagnostics = await runOutputPasses({ config, outputPath: '/repo/src/gen', hooks })
+ * ```
+ */
+export declare function runOutputPasses({ config, outputPath, hooks, signal }: RunOutputPassesOptions): Promise<Array<Diagnostic>>;
+//#endregion
+//#region src/createKubb.d.ts
+type CreateKubbOptions = {
+  /**
+   * Receives Kubb lifecycle hooks for the run.
+   */
+  hooks?: Hookable<KubbHooks>;
+  /**
+   * Stops the build at the next safe checkpoint.
+   */
+  signal?: AbortSignal;
+};
+/**
+ * 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 = {
+  /**
+   * Replaces the output passes that run after an error-free build. The default,
+   * {@link runOutputPasses}, formats, lints and runs `output.postGenerate` over the generated
+   * output and returns the diagnostics they emitted.
+   */
+  processOutput?: (context: RunOutputPassesOptions) => 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`,
+ * `storage`, and `driver` across the `setup → build` lifecycle.
+ *
+ * `createKubb` takes a plain config object (the shape `defineConfig` produces),
+ * not a fluent builder.
+ *
+ * Attach hook listeners to `.hooks` before calling `setup()` or `build()`.
+ *
+ * @example
+ * ```ts
+ * const kubb = createKubb(userConfig)
+ * kubb.hooks.hook('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
+ * const { files, diagnostics } = await kubb.safeBuild()
+ * ```
+ */
+declare class Kubb {
+  #private;
+  readonly hooks: Hookable<KubbHooks>;
+  readonly config: Config;
+  constructor(userConfig: UserConfig, options?: CreateKubbOptions);
+  get storage(): Storage;
+  get driver(): KubbDriver;
+  /**
+   * Initializes the driver and storage. `build()` calls this automatically.
+   */
+  setup(): Promise<void>;
+  /**
+   * Runs the full pipeline and throws on any plugin error.
+   * Automatically calls `setup()` if needed.
+   */
+  build(): Promise<BuildOutput>;
+  /**
+   * Runs the full pipeline and captures errors in `BuildOutput` instead of throwing.
+   * Automatically calls `setup()` if needed. This is the canonical call: it never throws on
+   * 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;
+}
+/**
+ * Constructs a {@link Kubb} build orchestrator from a user config. Equivalent
+ * to `new Kubb(userConfig, options)` and the canonical public entry point.
+ *
+ * @example
+ * ```ts
+ * import { createKubb } from '@kubb/core'
+ * import { adapterOas } from '@kubb/adapter-oas'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ *
+ * const kubb = createKubb({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   adapter: adapterOas(),
+ *   plugins: [pluginTs()],
+ * })
+ *
+ * await kubb.build()
+ * ```
+ */
+export declare function createKubb(userConfig: UserConfig, options?: CreateKubbOptions): Kubb;
+//#endregion
+//#region src/reporters/summary.d.ts
+/**
+ * Writes a finished summary. The `cli` reporter formats the lines and hands them to one of these,
+ * so the caller decides where they land: plain `console.log` by default, or the active logger's own
+ * output when a host installs one.
+ */
+type SummaryRenderer = (lines: ReadonlyArray<string>, meta: {
+  title: string;
+  status: 'success' | 'failed';
+}) => void;
+//#endregion
+//#region src/reporters/cliReporter.d.ts
+/**
+ * Builds a `cli` reporter that renders the {@link Report} for each config as it finishes.
+ * Suppressed at `silent`. The `verbose` level adds the per-plugin timings.
+ *
+ * Pass `render` to send the summary through output the host already owns, so it lands inside that
+ * host's grouping instead of alongside it. Omit it for the plain `console.log` writer.
+ *
+ * @example
+ * ```ts
+ * const reporter = createCliReporter({ render: (lines) => lines.forEach((line) => clack.log.message(line)) })
+ * ```
+ */
+export declare function createCliReporter({ render }?: {
+  render?: SummaryRenderer;
+}): Reporter;
+/**
+ * The default `cli` reporter, writing its summary straight to the console. Independent of the live
+ * logger view.
+ */
+export declare const cliReporter: Reporter;
+//#endregion
+//#region src/reporters/fileReporter.d.ts
+/**
+ * The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
+ * plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same lines the
+ * cli reporter prints (timings included), and a `## Problems` section in the miette block format.
+ * Selected with `--reporter file` (or `reporters: ['file']`).
+ *
+ * @note It captures the collected diagnostics once a config finishes, not the live
+ * `kubb:info`/`kubb:plugin` hook stream. Color is stripped so the file stays plain text even when
+ * the run is attached to a TTY.
+ */
+export declare const fileReporter: Reporter;
+//#endregion
+//#region src/reporters/jsonReporter.d.ts
+/**
+ * The `json` reporter. `report` returns one config's {@link Report}, which {@link createReporter}
+ * buffers, and `drain` writes them as a single pretty-printed JSON array on `kubb:lifecycle:end`.
+ * Buffering keeps a multi-config run one valid JSON document on stdout instead of concatenated
+ * objects that would break `jq .`. The terminal reporter is suppressed while `json` is active so
+ * stdout stays valid JSON.
+ */
+export declare const jsonReporter: Reporter;
+//#endregion
+//#region src/reporters/htmlReporter.d.ts
+/**
+ * Writes a static HTML report directory selected with `--reporter html`.
+ */
+export declare const htmlReporter: Reporter;
+//#endregion
+//#region src/createResolver.d.ts
+/**
+ * The plugin-specific resolver fields handed to `createResolver`. `name` and `file` fall
+ * back to the built-ins when omitted. Every method reaches sibling helpers through `this`,
+ * which `ThisType` types as the full resolver.
+ */
+type ResolverOptions<T extends PluginType> = Omit<T['resolver'], keyof Resolver> & {
+  pluginName: T['name'];
+  name?: T['resolver']['name'];
+  file?: ResolverFile;
+} & ThisType<T['resolver']>;
+/**
+ * Defines a plugin resolver, the object that decides what every generated symbol and file
+ * path is called. Override the top-level `name` and `file` to set the plugin's conventions,
+ * and add your own naming helpers, top-level (`typeName`, …) or grouped in namespaces
+ * (`query`, `schema`, …). Every method reaches sibling helpers and the built-in machinery
+ * through `this.name`, `this.file`, and `this.default`.
+ *
+ * @example Custom identifier casing
+ * ```ts
+ * export const resolverTs = createResolver<PluginTs>({
+ *   pluginName: 'plugin-ts',
+ *   name(name) {
+ *     return ensureValidVarName(pascalCase(name))
+ *   },
+ * })
+ * ```
+ *
+ * @example Rename generated files with `file.baseName`
+ * ```ts
+ * export const resolverFaker = createResolver<PluginFaker>({
+ *   pluginName: 'plugin-faker',
+ *   name(name) {
+ *     return camelCase(name, { prefix: 'create' })
+ *   },
+ *   file: {
+ *     baseName({ name, extname }) {
+ *       return `${camelCase(name, { prefix: 'create' })}${extname}`
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * @example Own the full path with `file.path`
+ * ```ts
+ * export const resolverFaker = createResolver<PluginFaker>({
+ *   pluginName: 'plugin-faker',
+ *   file: {
+ *     path({ baseName, output }) {
+ *       return `${output.path}/mocks/${baseName}`
+ *     },
+ *   },
+ * })
+ * ```
+ */
+export declare function createResolver<T extends PluginType>(options: ResolverOptions<T>): T['resolver'];
+//#endregion
+//#region src/input.d.ts
+/**
+ * What an `input` value points at, once Kubb has looked at it.
+ *
+ * - `file` is a local file path, absolute or relative to the config file.
+ * - `url` is a remote document to fetch.
+ * - `inline` is OpenAPI content held in the string itself (JSON or YAML).
+ * - `object` is an already-parsed spec.
+ */
+type InputKind = 'file' | 'url' | 'inline' | 'object';
+/**
+ * Classifies an `input` value so callers branch on it once instead of repeating the checks.
+ *
+ * A non-string is a parsed spec (`object`). A string is `inline` when it holds OpenAPI content,
+ * meaning it starts with `{` or `[`, spans multiple lines, or opens with a YAML `openapi:` or
+ * `swagger:` key. Otherwise a string is a `url` when it parses as one, or a `file` path.
+ */
+export declare function getInputKind(input: NonNullable<Input>): InputKind;
+//#endregion
+//#region src/storages/cacheStorage.d.ts
+type CacheStorageOptions = {
+  /**
+   * Project root the cache directory is derived from.
+   *
+   * @default process.cwd()
+   */
+  root?: string;
+};
+/**
+ * Directory Kubb keeps build caches in. A project with a `node_modules` gets
+ * `node_modules/.cache/kubb`, the convention babel and eslint already use, so the cache stays out
+ * of version control. Without one it falls back to the OS temp directory, keyed by root so two
+ * projects sharing that directory keep their own cache.
+ *
+ * @example Inside a project
+ * `resolveCacheDir('/project') // '/project/node_modules/.cache/kubb'`
+ */
+export declare function resolveCacheDir(root: string): string;
+/**
+ * Filesystem storage for build caches rather than generated code. Keys are plain names resolved
+ * inside {@link resolveCacheDir}, so a caller stores `'x.json'` without knowing where the cache
+ * lives. Kept apart from the configured output storage, which may not be a local disk at all.
+ *
+ * @example
+ * ```ts
+ * const cache = cacheStorage({ root: config.root })
+ * await cache.writeItem('output-manifest.json', JSON.stringify(entries))
+ * ```
+ */
+export declare const cacheStorage: (options?: CacheStorageOptions | undefined) => Storage;
+//#endregion
+//#region src/storages/fsStorage.d.ts
+/**
+ * Built-in filesystem storage driver.
+ *
+ * This is the default storage when no `storage` option is configured in the root config.
+ * Keys are resolved against `process.cwd()`, so root-relative paths such as
+ * `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
+ *
+ * Writes are deduplicated and directory-safe:
+ * - leading and trailing whitespace is trimmed before writing
+ * - the write is skipped when the file already holds that content, ignoring any trailing newline
+ *   a formatter left behind
+ * - missing parent directories are created automatically
+ * - `FileManager.write` bounds in-flight writes, so this driver does not pace itself
+ *
+ * @example
+ * ```ts
+ * import { fsStorage } from '@kubb/core'
+ * import { defineConfig } from 'kubb'
+ *
+ * export default defineConfig({
+ *   input:  './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   storage: fsStorage(),
+ * })
+ * ```
+ */
+export declare const fsStorage: (options?: Record<string, never> | undefined) => Storage;
+//#endregion
+//#region src/storages/kubbStorage.d.ts
+type KubbStorageOptions = {
+  /**
+   * Folder inside the Kubb home, or an absolute path such as `<cwd>/.kubb`.
+   */
+  base?: string;
+};
+/**
+ * Folder Kubb keeps its own files in, created with mode 0700. `base` resolves inside `KUBB_HOME`
+ * (default `~/.kubb`). When that folder is not writable, it falls back to a folder in the OS temp directory.
+ *
+ * @example
+ * `resolveKubbDir('cache') // '/home/me/.kubb/cache'`
+ */
+export declare function resolveKubbDir(base?: string): string;
+/**
+ * unstorage on the fs driver, rooted at {@link resolveKubbDir}. The fs driver cannot set a file
+ * mode, so the 0700 folder keeps files such as a stored token private.
+ *
+ * @example
+ * ```ts
+ * const storage = kubbStorage({ base: 'cache' })
+ * await storage.setItem('machine-secret', secret)
+ * ```
+ */
+export declare function kubbStorage({ base }?: KubbStorageOptions): import("unstorage").Storage<import("unstorage").StorageValue>;
+//#endregion
+//#region src/storages/memoryStorage.d.ts
+/**
+ * In-memory storage driver. Useful for testing and dry-run scenarios where
+ * generated output should be captured without touching the filesystem.
+ *
+ * All data lives in a `Map` scoped to the storage instance and is discarded
+ * when the instance is garbage-collected.
+ *
+ * @example
+ * ```ts
+ * import { memoryStorage } from '@kubb/core'
+ * import { defineConfig } from 'kubb'
+ *
+ * export default defineConfig({
+ *   input:  './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   storage: memoryStorage(),
+ * })
+ * ```
+ */
+export declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
+//#endregion
+//#region src/manifest.d.ts
+/** A value that survives `JSON.stringify` and `JSON.parse` unchanged. */
+type JSONValue = string | number | boolean | null | Array<JSONValue> | {
+  [key: string]: JSONValue;
+};
+/**
+ * One form field Studio renders for an extension. It edits the value at `path` in the options
+ * object the user passes to the factory.
+ */
+type ExtensionManifestOption = {
+  /** Stable UI key, unique within the manifest. */
+  key: string;
+  /** Where the value lives, such as `['output', 'path']`. */
+  path: Array<string>;
+  label: string;
+  description?: string;
+  type: 'select' | 'boolean' | 'text' | 'number' | 'list';
+  /** The extension's runtime default, shown when the option is unset. */
+  default?: JSONValue;
+  /** For `select`. A choice with value `null` leaves the option unset. */
+  choices?: Array<{
+    label?: string;
+    value: JSONValue;
+  }>;
+  /** For `boolean`: the value written for `true`, `true` when unset. */
+  trueValue?: JSONValue;
+  /** For `boolean`: the value written for `false`, `false` when unset. */
+  falseValue?: JSONValue;
+  /** For `list`: template for each entry, where every `"$item"` string is replaced by the entry. */
+  item?: JSONValue;
+  /** For `list`: upper-case each entry before writing it. */
+  itemCase?: 'upper';
+};
+/**
+ * The `kubb-extension.json` file an extension package ships at its root. Studio, the kubb.dev
+ * registry, and `kubb add` read it.
+ */
+type ExtensionManifest = {
+  $schema?: string;
+  kind: ExtensionKind;
+  /** Equals the extension's `meta.name`. */
+  name: string;
+  /** The factory export users call in `kubb.config.ts`, such as `pluginZod`. */
+  export: string;
+  displayName: string;
+  description: string;
+  category?: string;
+  icon?: {
+    light: string;
+    dark?: string;
+  };
+  /** HTTPS image or video URLs. */
+  media?: Array<string>;
+  tags?: Array<string>;
+  docs?: string;
+  /** People who maintain the extension, shown on its kubb.dev page. */
+  maintainers?: Array<{
+    name: string;
+    github?: string;
+  }>;
+  /** Names of the extensions that must be in the same config, such as `['plugin-ts']`. */
+  dependencies?: Array<string>;
+  /** Names of the extensions used when they are in the config, or needed only for some option values, such as `['plugin-faker']`. */
+  optionalDependencies?: Array<string>;
+  compatibility?: {
+    kubb?: string;
+    node?: string;
+  };
+  /** Plugins only: `client` ships the HTTP client runtime, `consumer` calls one but ships none. */
+  role?: 'client' | 'consumer';
+  options?: Array<ExtensionManifestOption>;
+};
+/** What `kubb add` installs: a reviewed npm version, or a GitHub release tag and the commit it points to. */
+type RegistryArtifact = {
+  kind: 'npm';
+  package: string;
+  version: string;
+} | {
+  kind: 'github';
+  /** The `name` in the root `package.json`, so the package installs under this name. */
+  package: string;
+  /** The release version, equal to `tag` without a leading `v`. */
+  version: string;
+  owner: string;
+  repo: string;
+  tag: string;
+  /** The full commit SHA the tag points to. */
+  commit: string;
+};
+/** One extension in a registry's `index.json`. */
+type RegistryEntry = {
+  /** `<owner>/<slug>`, such as `kubb-labs/plugin-zod`. */
+  id: string;
+  kind: ExtensionKind;
+  type: 'official' | 'community';
+  artifact: RegistryArtifact;
+  repository?: {
+    url: string;
+  };
+  manifest: ExtensionManifest;
+  stats?: {
+    downloads?: number;
+    weekly?: number;
+    stars?: number;
+  };
+  submittedAt: string;
+  publishedAt: string;
+  reviewedAt: string;
+};
+/** The registry's `index.json`. */
+type RegistryIndex = {
+  version: 1;
+  generatedAt: string;
+  extensions: Array<RegistryEntry>;
+};
+/** One `docs/guides/<id>.md`: `id` is the file name, `title` its `#` heading, `description` the first paragraph. */
+type RegistryGuide = {
+  id: string;
+  title: string;
+  description: string;
+  content: string;
+};
+/** The registry's `<owner>/<slug>.json`: an entry plus the Markdown docs its pinned version ships. */
+type RegistryDetail = RegistryEntry & {
+  overview: string | null;
+  options?: string | null;
+  guides?: Array<RegistryGuide>;
+};
+/**
+ * Whether `name` is a valid npm package name, such as `@kubb/plugin-ts`. Rejects paths, URLs,
+ * `node:` specifiers, and names that start with `-`, so the result is safe to pass to `import()` or
+ * a package manager.
+ */
+export declare function isPackageName(name: unknown): name is string;
+/**
+ * What is wrong with the options of a well-formed manifest, beyond their shape: keys are unique, a
+ * select has choices, and a select's default is one of its choice values. Empty when they pass.
+ */
+export declare function manifestProblems({ options }: ExtensionManifest): Array<string>;
+/**
+ * Checks a parsed `kubb-extension.json` or a registry response before Kubb or Studio uses it: the
+ * fields Kubb reads, every option's shape (including option paths that cannot reach a prototype),
+ * and `manifestProblems`. A malformed manifest is skipped instead of trusted.
+ */
+export declare function isExtensionManifest(value: unknown): value is ExtensionManifest;
+/**
+ * Checks one entry of a registry's `index.json` or `<owner>/<slug>.json`: a full `<owner>/<slug>` id,
+ * an npm or GitHub artifact pinned to a valid version, and a valid manifest of the entry's kind.
+ */
+export declare function isRegistryEntry(value: unknown): value is RegistryEntry;
+//#endregion
+//#region src/installedPackages.d.ts
+type InstalledPackage = {
+  package: string;
+  version?: string;
+  manifest?: ExtensionManifest;
+};
+/**
+ * The `dependencies` and `devDependencies` of the project at `root`, plus `packages`, with the
+ * installed version and the valid `kubb-extension.json` each one ships, when it does. A package
+ * also counts as installed when it resolves from one of the `resolveFrom` packages, such as `kubb`
+ * for the extensions it ships with.
+ */
+export declare function readInstalledPackages({ root, packages, resolveFrom }: {
+  root: string;
+  packages?: Iterable<string>;
+  resolveFrom?: Array<string>;
+}): Promise<Array<InstalledPackage>>;
+//#endregion
+export { type Adapter, type AdapterDefinition, type AdapterFactory, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticFormatOptions, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type ExtensionDependencies, type ExtensionDependency, type ExtensionDependencyRecord, type ExtensionFactory, type ExtensionKind, type ExtensionManifest, type ExtensionManifestOption, type ExtensionMeta, FilesContext, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, type HookResult, Hookable, type Include, Input, type InputKind, type InstalledPackage, type JSONValue, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbGenerationSummaryContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, KubbMessageContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NodeCache, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type ParserDefinition, type ParserFactory, type PerformanceDiagnostic, type Plugin, type PluginDefinition, type PluginFactory, type PluginName, type PluginType, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type RegistryArtifact, type RegistryDetail, type RegistryEntry, type RegistryGuide, type RegistryIndex, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ReporterPluginFiles, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type RunHookOptions, type RunOutputPassesOptions, type SerializedDiagnostic, type Storage, type SummaryRenderer, type UpdateDiagnostic, UserConfig, type UserReporter, assertPluginOption, checkCompatibility, createAdapter, createRenderer, createReporter, createStorage, defineExtension, defineGenerator, defineParser, definePlugin, logLevel, resolveMeta, runHook };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { $ as NodeCache, $t as UpdateDiagnostic, A as PluginFactory, At as RunHookOptions, B as ResolveImportsOptions, Bt as UserReporter, C as NormalizedPlugin, Ct as KubbPluginsEndContext, D as Override, Dt as PostGenerateCommand, E as OutputOptions, Et as PossibleConfig, F as definePlugin, Ft as GenerationResult, G as ResolverFile, Gt as DiagnosticKind, H as ResolvePathOptions, Ht as logLevel, I as BannerMeta, It as Reporter, J as ResolverPatch, Jt as Diagnostics, K as ResolverFileParams, Kt as DiagnosticLocation, L as ResolveBannerContext, Lt as ReporterContext, M as PluginType, Mt as KubbDriver, N as ResolvePluginOptions, Nt as Storage, O as Plugin, Ot as UserConfig, P as assertPluginOption, Pt as createStorage, Q as defineGenerator, Qt as SerializedDiagnostic, R as ResolveBannerFile, Rt as ReporterName, S as KubbPluginStartContext, St as KubbMessageContext, T as OutputMode, Tt as KubbWarnContext, U as Resolver, Ut as Diagnostic, V as ResolveOptionsContext, Vt as createReporter, W as ResolverDefault, Wt as DiagnosticDoc, X as Generator, Xt as ProblemCode, Y as ResolverPathParams, Yt as PerformanceDiagnostic, Z as GeneratorContext, Zt as ProblemDiagnostic, _ as Filter, _t as KubbHookLineContext, a as AdapterSource, an as ParserDefinition, at as KubbBuildEndContext, b as KubbPluginEndContext, bt as KubbInfoContext, c as ExtensionDependency, ct as KubbErrorContext, d as ExtensionKind, dt as KubbFilesProcessingStartContext, en as Hookable, et as BuildOutput, f as ExtensionMeta, ft as KubbFilesProcessingUpdateContext, g as Exclude, gt as KubbHookEndContext, h as resolveMeta, ht as KubbGenerationSummaryContext, i as AdapterFactoryOptions, in as Parser, it as Input, j as PluginName, jt as runHook, k as PluginDefinition, kt as HookResult, l as ExtensionDependencyRecord, lt as KubbFileProcessingUpdate, m as defineExtension, mt as KubbGenerationStartContext, n as AdapterDefinition, nn as RendererFactory, nt as Config, o as createAdapter, on as ParserFactory, ot as KubbBuildStartContext, p as checkCompatibility, pt as KubbGenerationEndContext, q as ResolverFilePathParams, qt as DiagnosticSeverity, r as AdapterFactory, rn as createRenderer, rt as FilesContext, s as ExtensionDependencies, sn as defineParser, st as KubbDiagnosticContext, t as Adapter, tn as Renderer, tt as CLIOptions, u as ExtensionFactory, ut as KubbFilesProcessingEndContext, v as Group, vt as KubbHookStartContext, w as Output, wt as KubbSuccessContext, x as KubbPluginSetupContext, xt as KubbLifecycleStartContext, y as Include, yt as KubbHooks, z as ResolveFileOptions, zt as ReporterPluginFiles } from "./createAdapter-D55JE9lX.js";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { $ as NodeCache, $t as ReporterPluginFiles, A as PluginFactory, At as KubbInfoContext, B as ResolveImportsOptions, Bt as RunHookOptions, C as NormalizedPlugin, Ct as KubbGenerationEndContext, D as Override, Dt as KubbHookLineContext, E as OutputOptions, Et as KubbHookEndContext, F as definePlugin, Ft as KubbWarnContext, G as ResolverFile, Gt as RendererFactory, H as ResolvePathOptions, Ht as KubbDriver, I as BannerMeta, It as PossibleConfig, J as ResolverPatch, Jt as createStorage, K as ResolverFileParams, Kt as createRenderer, L as ResolveBannerContext, Lt as PostGenerateCommand, M as PluginType, Mt as KubbMessageContext, N as ResolvePluginOptions, Nt as KubbPluginsEndContext, O as Plugin, Ot as KubbHookStartContext, P as assertPluginOption, Pt as KubbSuccessContext, Q as defineGenerator, Qt as ReporterName, R as ResolveBannerFile, Rt as UserConfig, S as KubbPluginStartContext, St as KubbFilesProcessingUpdateContext, T as OutputMode, Tt as KubbGenerationSummaryContext, U as Resolver, Ut as Hookable, V as ResolveOptionsContext, Vt as runHook, W as ResolverDefault, Wt as Renderer, X as Generator, Xt as Reporter, Y as ResolverPathParams, Yt as GenerationResult, Z as GeneratorContext, Zt as ReporterContext, _ as Filter, _t as KubbDiagnosticContext, a as AdapterSource, an as Parser, at as Diagnostics, b as KubbPluginEndContext, bt as KubbFilesProcessingEndContext, c as ExtensionDependency, cn as defineParser, ct as ProblemDiagnostic, d as ExtensionKind, dt as CLIOptions, en as UserReporter, et as Diagnostic, f as ExtensionMeta, ft as Config, g as Exclude, gt as KubbBuildStartContext, h as resolveMeta, ht as KubbBuildEndContext, i as AdapterFactoryOptions, in as SerializedDiagnostic, it as DiagnosticSeverity, j as PluginName, jt as KubbLifecycleStartContext, k as PluginDefinition, kt as KubbHooks, l as ExtensionDependencyRecord, lt as UpdateDiagnostic, m as defineExtension, mt as Input, n as AdapterDefinition, nn as logLevel, nt as DiagnosticKind, o as createAdapter, on as ParserDefinition, ot as PerformanceDiagnostic, p as checkCompatibility, pt as FilesContext, q as ResolverFilePathParams, qt as Storage, r as AdapterFactory, rn as DiagnosticFormatOptions, rt as DiagnosticLocation, s as ExtensionDependencies, sn as ParserFactory, st as ProblemCode, t as Adapter, tn as createReporter, tt as DiagnosticDoc, u as ExtensionFactory, ut as BuildOutput, v as Group, vt as KubbErrorContext, w as Output, wt as KubbGenerationStartContext, x as KubbPluginSetupContext, xt as KubbFilesProcessingStartContext, y as Include, yt as KubbFileProcessingUpdate, z as ResolveFileOptions, zt as HookResult } from "./createAdapter-B5kKMsWV.js";
 import { FileNode, Macro, UserFileNode } from "@kubb/ast";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/composables.d.ts
 /**
  * Holds the setup context of the plugin whose `setup` or `kubb:plugin:setup` is running. `KubbDriver` sets it for each plugin.
@@ -617,5 +616,5 @@ export declare function readInstalledPackages({ root, packages, resolveFrom }: {
   resolveFrom?: Array<string>;
 }): Promise<Array<InstalledPackage>>;
 //#endregion
-export { type Adapter, type AdapterDefinition, type AdapterFactory, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type ExtensionDependencies, type ExtensionDependency, type ExtensionDependencyRecord, type ExtensionFactory, type ExtensionKind, type ExtensionManifest, type ExtensionManifestOption, type ExtensionMeta, FilesContext, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, type HookResult, Hookable, type Include, Input, type InputKind, type InstalledPackage, type JSONValue, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbGenerationSummaryContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, KubbMessageContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NodeCache, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type ParserDefinition, type ParserFactory, type PerformanceDiagnostic, type Plugin, type PluginDefinition, type PluginFactory, type PluginName, type PluginType, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type RegistryArtifact, type RegistryDetail, type RegistryEntry, type RegistryGuide, type RegistryIndex, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ReporterPluginFiles, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type RunHookOptions, type RunOutputPassesOptions, type SerializedDiagnostic, type Storage, type SummaryRenderer, type UpdateDiagnostic, UserConfig, type UserReporter, assertPluginOption, checkCompatibility, createAdapter, createRenderer, createReporter, createStorage, defineExtension, defineGenerator, defineParser, definePlugin, logLevel, resolveMeta, runHook };
+export { type Adapter, type AdapterDefinition, type AdapterFactory, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticFormatOptions, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type ExtensionDependencies, type ExtensionDependency, type ExtensionDependencyRecord, type ExtensionFactory, type ExtensionKind, type ExtensionManifest, type ExtensionManifestOption, type ExtensionMeta, FilesContext, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, type HookResult, Hookable, type Include, Input, type InputKind, type InstalledPackage, type JSONValue, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbGenerationSummaryContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, KubbMessageContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NodeCache, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type ParserDefinition, type ParserFactory, type PerformanceDiagnostic, type Plugin, type PluginDefinition, type PluginFactory, type PluginName, type PluginType, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type RegistryArtifact, type RegistryDetail, type RegistryEntry, type RegistryGuide, type RegistryIndex, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ReporterPluginFiles, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type RunHookOptions, type RunOutputPassesOptions, type SerializedDiagnostic, type Storage, type SummaryRenderer, type UpdateDiagnostic, UserConfig, type UserReporter, assertPluginOption, checkCompatibility, createAdapter, createRenderer, createReporter, createStorage, defineExtension, defineGenerator, defineParser, definePlugin, logLevel, resolveMeta, runHook };
 //# sourceMappingURL=index.d.ts.map