@kubb/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { $ as defineParser, A as KubbPluginStartContext, B as Override, C as KubbGenerationSummaryContext, D as KubbLifecycleStartContext, E as KubbInfoContext, F as Logger, G as ResolveOptionsContext, H as PossibleConfig, I as LoggerContext, J as ResolverFileParams, K as Resolver, L as LoggerOptions, M as KubbSuccessContext, N as KubbVersionNewContext, O as KubbPluginEndContext, P as KubbWarnContext, Q as Parser, R as NormalizedPlugin, S as KubbGenerationStartContext, T as KubbHookStartContext, U as ResolveBannerContext, V as PluginFactoryOptions, W as ResolveNameParams, X as UserConfig, Y as ResolverPathParams, Z as UserLogger, _ as KubbErrorContext, _t as logLevel, a as Config, at as createKubb, b as KubbFilesProcessingStartContext, c as GeneratorContext, ct as Plugin, d as InputData, dt as defineGenerator, et as Middleware, f as InputPath, ft as Storage, g as KubbDebugContext, gt as createRenderer, h as KubbConfigEndContext, ht as RendererFactory, i as CLIOptions, it as BuildOutput, j as KubbPluginsEndContext, k as KubbPluginSetupContext, l as Group, lt as definePlugin, m as KubbBuildStartContext, mt as Renderer, n as AdapterFactoryOptions, nt as Kubb, o as DevtoolsOptions, ot as PluginDriver, p as KubbBuildEndContext, pt as createStorage, q as ResolverContext, r as AdapterSource, rt as KubbHooks, s as Exclude, st as FileManager, t as Adapter, tt as defineMiddleware, u as Include, ut as Generator, v as KubbFileProcessingUpdateContext, vt as AsyncEventEmitter, w as KubbHookEndContext, x as KubbGenerationEndContext, y as KubbFilesProcessingEndContext, z as Output } from "./types-Cd0jhNmx.js";
+import { t as __name } from "./chunk-C0LytTxp.js";
+import { $ as Override, A as KubbHookEndContext, At as logLevel, B as createKubb, Bt as AsyncEventEmitter, C as KubbErrorContext, Ct as createReporter, D as KubbFilesProcessingUpdateContext, Dt as LoggerOptions, E as KubbFilesProcessingStartContext, Et as LoggerContext, F as KubbPluginsEndContext, Ft as createStorage, G as Exclude, H as GeneratorContext, I as KubbSuccessContext, It as Adapter, J as KubbPluginEndContext, K as Group, L as KubbWarnContext, Lt as AdapterFactoryOptions, M as KubbHooks, Mt as RendererFactory, N as KubbInfoContext, Nt as createRenderer, O as KubbGenerationEndContext, Ot as UserLogger, P as KubbLifecycleStartContext, Pt as Storage, Q as Output, R as PossibleConfig, Rt as AdapterSource, S as KubbDiagnosticContext, St as UserReporter, T as KubbFilesProcessingEndContext, Tt as Logger, U as defineGenerator, V as Generator, W as KubbDriver, X as KubbPluginStartContext, Y as KubbPluginSetupContext, Z as NormalizedPlugin, _ as InputPath, _t as defineParser, a as DiagnosticLocation, at as ResolveBannerFile, b as KubbBuildStartContext, bt as ReporterContext, c as PerformanceDiagnostic, ct as ResolverContext, d as SerializedDiagnostic, dt as defineResolver, et as Plugin, f as UpdateDiagnostic, ft as Middleware, g as InputData, gt as Parser, h as Config, ht as ParsedFile, i as DiagnosticKind, it as ResolveBannerContext, j as KubbHookStartContext, jt as Renderer, k as KubbGenerationStartContext, kt as defineLogger, l as ProblemCode, lt as ResolverFileParams, m as CLIOptions, mt as FileProcessorHooks, n as DiagnosticByCode, nt as definePlugin, o as DiagnosticSeverity, ot as ResolveOptionsContext, p as BuildOutput, pt as defineMiddleware, q as Include, r as DiagnosticDoc, rt as BannerMeta, s as Diagnostics, st as Resolver, t as Diagnostic, tt as PluginFactoryOptions, u as ProblemDiagnostic, ut as ResolverPathParams, v as Kubb, vt as GenerationResult, w as KubbFileProcessingUpdate, wt as selectReporters, x as KubbConfigEndContext, xt as ReporterName, y as KubbBuildEndContext, yt as Reporter, z as UserConfig, zt as createAdapter } from "./diagnostics-DhfW8YpT.js";
 import * as ast from "@kubb/ast";
-import { FileNode, InputNode, Node } from "@kubb/ast";
 
 //#region ../../internals/utils/src/urlPath.d.ts
 type URLObject = {
@@ -114,7 +113,7 @@ declare class URLPath {
     prefix,
     replacer
   }?: {
-    prefix?: string;
+    prefix?: string | null;
     replacer?: (pathParam: string) => string;
   }): string;
   /**
@@ -139,179 +138,185 @@ declare class URLPath {
   toURLPath(): string;
 }
 //#endregion
-//#region src/createAdapter.d.ts
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
+//#region src/reporters/cliReporter.d.ts
 /**
- * Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
- *
- * Use this to support GraphQL schemas, gRPC definitions, AsyncAPI, or custom domain-specific languages.
- * Built-in adapters include `@kubb/adapter-oas` for OpenAPI and Swagger documents.
- *
- * @note Adapters must parse their input format to Kubb's `InputNode` structure.
- *
- * @example
- * ```ts
- * export const myAdapter = createAdapter<MyAdapter>((options) => {
- *   return {
- *     name: 'my-adapter',
- *     options,
- *     async parse(source) {
- *       // Transform source format to InputNode
- *       return { ... }
- *     },
- *   }
- * })
- *
- * // Instantiate:
- * const adapter = myAdapter({ validate: true })
- * ```
+ * The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
+ * of the live logger view. Suppressed at `silent`; the `verbose` level adds the per-plugin timings.
  */
-declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
+declare const cliReporter: Reporter;
 //#endregion
-//#region src/defineLogger.d.ts
+//#region src/reporters/fileReporter.d.ts
 /**
- * Wraps a logger definition into a typed {@link Logger}.
+ * 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 counts the
+ * cli and json reporters expose, a `## Problems` section in the miette block format, and a
+ * `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`), replacing the
+ * old `--debug` flag.
  *
- * @example
- * ```ts
- * export const myLogger = defineLogger({
- *   name: 'my-logger',
- *   install(context, options) {
- *     context.on('kubb:info', (message) => console.log('ℹ', message))
- *     context.on('kubb:error', (error) => console.error('✗', error.message))
- *   },
- * })
- * ```
+ * @note Unlike the streaming logger it replaced, it captures the collected diagnostics once a
+ * config finishes, not the live `kubb:info`/`kubb:plugin` event stream. Color is stripped so the
+ * file stays plain text even when the run is attached to a TTY.
  */
-declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
+declare const fileReporter: Reporter;
 //#endregion
-//#region src/defineResolver.d.ts
+//#region src/reporters/jsonReporter.d.ts
 /**
- * Builder type for the plugin-specific resolver fields.
- *
- * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
- * are optional — built-in fallbacks are injected when omitted.
- *
- * The builder receives `ctx` — a reference to the fully assembled resolver — so methods can
- * call sibling resolver methods without using `this`.  Because `ctx` is captured by the closure
- * and the resolver is populated after the builder runs, `ctx` correctly reflects any overrides
- * that were applied by the builder itself.
+ * 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.
  */
-type ResolverBuilder<T extends PluginFactoryOptions> = (ctx: T['resolver']) => Omit<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'> & Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
+declare const jsonReporter: Reporter;
+//#endregion
+//#region src/Telemetry.d.ts
+type OtlpStringValue = {
+  stringValue: string;
+};
+type OtlpBoolValue = {
+  boolValue: boolean;
+};
+type OtlpIntValue = {
+  intValue: number;
+};
+type OtlpDoubleValue = {
+  doubleValue: number;
+};
+type OtlpBytesValue = {
+  bytesValue: string;
+};
+type OtlpArrayValue = {
+  arrayValue: {
+    values: Array<OtlpAnyValue>;
+  };
+};
+type OtlpKvListValue = {
+  kvlistValue: {
+    values: Array<OtlpKeyValue>;
+  };
+};
+type OtlpAnyValue = OtlpStringValue | OtlpBoolValue | OtlpIntValue | OtlpDoubleValue | OtlpBytesValue | OtlpArrayValue | OtlpKvListValue;
+type OtlpKeyValue = {
+  key: string;
+  value: OtlpAnyValue;
+};
+type OtlpResource = {
+  attributes: Array<OtlpKeyValue>;
+  droppedAttributesCount?: number;
+};
+type OtlpInstrumentationScope = {
   name: string;
-  pluginName: T['name'];
+  version?: string;
+  attributes?: Array<OtlpKeyValue>;
+  droppedAttributesCount?: number;
+};
+/** https://github.com/open-telemetry/opentelemetry-proto/blob/main/opentelemetry/proto/trace/v1/trace.proto#L103 */
+type OtlpSpanKind = 0 | 1 | 2 | 3 | 4 | 5;
+/** 0 = STATUS_CODE_UNSET, 1 = STATUS_CODE_OK, 2 = STATUS_CODE_ERROR */
+type OtlpStatusCode = 0 | 1 | 2;
+type OtlpStatus = {
+  code: OtlpStatusCode;
+  message?: string;
+};
+type OtlpSpan = {
+  traceId: string;
+  spanId: string;
+  traceState?: string;
+  parentSpanId?: string;
+  name: string;
+  kind: OtlpSpanKind;
+  startTimeUnixNano: string;
+  endTimeUnixNano: string;
+  attributes?: Array<OtlpKeyValue>;
+  droppedAttributesCount?: number;
+  events?: Array<OtlpSpanEvent>;
+  droppedEventsCount?: number;
+  links?: Array<OtlpSpanLink>;
+  droppedLinksCount?: number;
+  status?: OtlpStatus;
+};
+type OtlpSpanEvent = {
+  timeUnixNano: string;
+  name: string;
+  attributes?: Array<OtlpKeyValue>;
+  droppedAttributesCount?: number;
+};
+type OtlpSpanLink = {
+  traceId: string;
+  spanId: string;
+  traceState?: string;
+  attributes?: Array<OtlpKeyValue>;
+  droppedAttributesCount?: number;
+};
+type OtlpScopeSpans = {
+  scope: OtlpInstrumentationScope;
+  spans: Array<OtlpSpan>;
+  schemaUrl?: string;
+};
+type OtlpResourceSpans = {
+  resource: OtlpResource;
+  scopeSpans: Array<OtlpScopeSpans>;
+  schemaUrl?: string;
+};
+/** Root payload sent to POST /v1/traces */
+type OtlpExportTraceServiceRequest = {
+  resourceSpans: Array<OtlpResourceSpans>;
 };
 /**
- * Default option resolver — applies include/exclude filters and merges matching override options.
- *
- * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
- *
- * @example Include/exclude filtering
- * ```ts
- * const options = defaultResolveOptions(operationNode, {
- *   options: { output: 'types' },
- *   exclude: [{ type: 'tag', pattern: 'internal' }],
- * })
- * // → null when node has tag 'internal'
- * ```
- *
- * @example Override merging
- * ```ts
- * const options = defaultResolveOptions(operationNode, {
- *   options: { enumType: 'asConst' },
- *   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
- * })
- * // → { enumType: 'enum' } when operationId matches
- * ```
- */
-/**
- * Defines a resolver for a plugin, injecting built-in defaults for name casing,
- * include/exclude/override filtering, path resolution, and file construction.
- *
- * All four defaults can be overridden by providing them in the builder function:
- * - `default` — name casing strategy (camelCase / PascalCase)
- * - `resolveOptions` — include/exclude/override filtering
- * - `resolvePath` — output path computation
- * - `resolveFile` — full `FileNode` construction
- *
- * The builder receives `ctx` — a reference to the assembled resolver — so methods can
- * call sibling resolver methods using `ctx` instead of `this`.
- *
- * @example Basic resolver with naming helpers
- * ```ts
- * export const resolver = defineResolver<PluginTs>((ctx) => ({
- *   name: 'default',
- *   resolveName(node) {
- *     return ctx.default(node.name, 'function')
- *   },
- *   resolveTypedName(node) {
- *     return ctx.default(node.name, 'type')
- *   },
- * }))
- * ```
- *
- * @example Override resolvePath for a custom output structure
- * ```ts
- * export const resolver = defineResolver<PluginTs>((_ctx) => ({
- *   name: 'custom',
- *   resolvePath({ baseName }, { root, output }) {
- *     return path.resolve(root, output.path, 'generated', baseName)
- *   },
- * }))
- * ```
- *
- * @example Use ctx.default inside a helper
- * ```ts
- * export const resolver = defineResolver<PluginTs>((ctx) => ({
- *   name: 'default',
- *   resolveParamName(node, param) {
- *     return ctx.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
- *   },
- * }))
- * ```
+ * Anonymous plugin name and options snapshot sent with each telemetry event.
  */
-declare function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'];
-//#endregion
-//#region src/FileProcessor.d.ts
-type ParseOptions = {
-  parsers?: Map<FileNode['extname'], Parser>;
-  extension?: Record<FileNode['extname'], FileNode['extname'] | ''>;
-};
-type RunOptions = ParseOptions & {
+type TelemetryPlugin = {
   /**
-   * @default 'sequential'
+   * Plugin name as registered in the Kubb config, e.g. `'@kubb/plugin-ts'`.
    */
-  mode?: 'sequential' | 'parallel';
-  onStart?: (files: Array<FileNode>) => Promise<void> | void;
-  onEnd?: (files: Array<FileNode>) => Promise<void> | void;
-  onUpdate?: (params: {
-    file: FileNode;
-    source?: string;
-    processed: number;
-    total: number;
-    percentage: number;
-  }) => Promise<void> | void;
+  name: string;
+  /**
+   * anonymized plugin options snapshot, values are included but cannot be traced back to the user.
+   */
+  options: Record<string, unknown>;
+};
+type TelemetryEvent = {
+  command: string;
+  kubbVersion: string;
+  nodeVersion: string;
+  platform: string;
+  ci: boolean;
+  plugins: Array<TelemetryPlugin>;
+  duration: number;
+  filesCreated: number;
+  status: 'success' | 'failed';
 };
 /**
- * Converts a single file to a string using the registered parsers.
- * Falls back to joining source values when no matching parser is found.
- *
- * @internal
+ * Anonymous OTLP usage telemetry for the Kubb run. All methods are static, so call them as
+ * `Telemetry.build(...)`, `Telemetry.send(...)`, and `Telemetry.isDisabled()`. No file paths,
+ * OpenAPI specs, or secrets are ever included, and sending fails silently to never break a run.
  */
-declare class FileProcessor {
-  #private;
-  parse(file: FileNode, {
-    parsers,
-    extension
-  }?: ParseOptions): Promise<string>;
-  run(files: Array<FileNode>, {
-    parsers,
-    mode,
-    extension,
-    onStart,
-    onEnd,
-    onUpdate
-  }?: RunOptions): Promise<Array<FileNode>>;
+declare class Telemetry {
+  /**
+   * Returns `true` when telemetry is disabled via `DO_NOT_TRACK` or `KUBB_DISABLE_TELEMETRY`.
+   */
+  static isDisabled(): boolean;
+  /**
+   * Build an anonymous telemetry payload from a completed generation run.
+   */
+  static build(options: {
+    command: 'generate' | 'mcp' | 'validate' | 'agent';
+    kubbVersion: string;
+    plugins?: Array<TelemetryPlugin>;
+    hrStart: [number, number];
+    filesCreated?: number;
+    status: 'success' | 'failed';
+  }): TelemetryEvent;
+  /**
+   * Convert a {@link TelemetryEvent} into an OTLP-compatible JSON trace payload.
+   * See https://opentelemetry.io/docs/languages/sdk-configuration/otlp-exporter/
+   */
+  static buildOtlpPayload(event: TelemetryEvent): OtlpExportTraceServiceRequest;
+  /**
+   * Send an anonymous telemetry event to the Kubb OTLP endpoint. Respects `DO_NOT_TRACK` and
+   * `KUBB_DISABLE_TELEMETRY`, and fails silently so telemetry never interrupts a run.
+   */
+  static send(event: TelemetryEvent): Promise<void>;
 }
 //#endregion
 //#region src/storages/fsStorage.d.ts
@@ -364,16 +369,5 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
-//#region src/utils/isInputPath.d.ts
-/**
- * Type guard to check if a given config has an `input.path`.
- */
-declare function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> & {
-  input: InputPath;
-};
-declare function isInputPath(config: Config | undefined): config is Config<InputPath> & {
-  input: InputPath;
-};
-//#endregion
-export { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BuildOutput, CLIOptions, Config, DevtoolsOptions, Exclude, FileManager, FileProcessor, Generator, GeneratorContext, Group, Include, InputData, InputPath, Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbConfigEndContext, KubbDebugContext, KubbErrorContext, KubbFileProcessingUpdateContext, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbGenerationSummaryContext, KubbHookEndContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, KubbPluginEndContext, KubbPluginSetupContext, KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbVersionNewContext, KubbWarnContext, Logger, LoggerContext, LoggerOptions, Middleware, NormalizedPlugin, Output, Override, Parser, Plugin, PluginDriver, PluginFactoryOptions, PossibleConfig, Renderer, RendererFactory, ResolveBannerContext, ResolveNameParams, ResolveOptionsContext, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, Storage, URLPath, UserConfig, UserLogger, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
+export { type Adapter, type AdapterFactoryOptions, type AdapterSource, AsyncEventEmitter, type BannerMeta, type BuildOutput, type CLIOptions, type Config, type Diagnostic, type DiagnosticByCode, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileProcessorHooks, type GenerationResult, type Generator, type GeneratorContext, type Group, type Include, type InputData, type InputPath, type Kubb, type KubbBuildEndContext, type KubbBuildStartContext, type KubbConfigEndContext, type KubbDiagnosticContext, KubbDriver, type KubbErrorContext, type KubbFileProcessingUpdate, type KubbFilesProcessingEndContext, type KubbFilesProcessingStartContext, type KubbFilesProcessingUpdateContext, type KubbGenerationEndContext, type KubbGenerationStartContext, type KubbHookEndContext, type KubbHookStartContext, type KubbHooks, type KubbInfoContext, type KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, type KubbPluginsEndContext, type KubbSuccessContext, type KubbWarnContext, type Logger, type LoggerContext, type LoggerOptions, type Middleware, type NormalizedPlugin, type Output, type Override, type ParsedFile, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, type PossibleConfig, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveOptionsContext, type Resolver, type ResolverContext, type ResolverFileParams, type ResolverPathParams, type SerializedDiagnostic, type Storage, Telemetry, URLPath, type UpdateDiagnostic, type UserConfig, type UserLogger, type UserReporter, ast, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fileReporter, fsStorage, jsonReporter, logLevel, memoryStorage, selectReporters };
 //# sourceMappingURL=index.d.ts.map