@kubb/core 5.0.0-beta.1 → 5.0.0-beta.11

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-CuNocrbJ.js";
+import { $ as ResolverPathParams, A as isInputPath, B as KubbPluginSetupContext, C as KubbPluginsEndContext, Ct as AsyncEventEmitter, D as PossibleConfig, E as KubbWarnContext, F as FileManager, G as Plugin, H as NormalizedPlugin, I as Exclude, J as ResolveBannerContext, K as PluginFactoryOptions, L as Group, M as GeneratorContext, N as defineGenerator, O as UserConfig, P as PluginDriver, Q as ResolverFileParams, R as Include, S as KubbLifecycleStartContext, St as logLevel, T as KubbVersionNewContext, U as Output, V as KubbPluginStartContext, W as Override, X as Resolver, Y as ResolveOptionsContext, Z as ResolverContext, _ as KubbGenerationSummaryContext, _t as createRenderer, a as InputPath, at as LoggerOptions, b as KubbHooks, bt as AdapterSource, c as KubbBuildStartContext, ct as FileProcessor, d as KubbErrorContext, dt as defineParser, et as defineResolver, f as KubbFileProcessingUpdateContext, ft as DevtoolsOptions, g as KubbGenerationStartContext, gt as RendererFactory, h as KubbGenerationEndContext, ht as Renderer, i as InputData, it as LoggerContext, j as Generator, k as createKubb, l as KubbConfigEndContext, lt as FileProcessorEvents, m as KubbFilesProcessingStartContext, mt as createStorage, n as CLIOptions, nt as defineMiddleware, o as Kubb, ot as UserLogger, p as KubbFilesProcessingEndContext, pt as Storage, q as definePlugin, r as Config, rt as Logger, s as KubbBuildEndContext, st as defineLogger, t as BuildOutput, tt as Middleware, u as KubbDebugContext, ut as Parser, v as KubbHookEndContext, vt as Adapter, w as KubbSuccessContext, x as KubbInfoContext, xt as createAdapter, y as KubbHookStartContext, yt as AdapterFactoryOptions, z as KubbPluginEndContext } from "./createKubb-BSfMDBwR.js";
 import * as ast from "@kubb/ast";
-import { FileNode, InputNode, Node } from "@kubb/ast";
 
 //#region ../../internals/utils/src/urlPath.d.ts
 type URLObject = {
@@ -139,181 +138,6 @@ declare class URLPath {
   toURLPath(): string;
 }
 //#endregion
-//#region src/createAdapter.d.ts
-type AdapterBuilder<T extends AdapterFactoryOptions> = (options: T['options']) => Adapter<T>;
-/**
- * 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 })
- * ```
- */
-declare function createAdapter<T extends AdapterFactoryOptions = AdapterFactoryOptions>(build: AdapterBuilder<T>): (options?: T['options']) => Adapter<T>;
-//#endregion
-//#region src/defineLogger.d.ts
-/**
- * Wraps a logger definition into a typed {@link Logger}.
- *
- * @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))
- *   },
- * })
- * ```
- */
-declare function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options>;
-//#endregion
-//#region src/defineResolver.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.
- */
-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'>> & {
-  name: string;
-  pluginName: T['name'];
-};
-/**
- * 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')
- *   },
- * }))
- * ```
- */
-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 & {
-  /**
-   * @default 'sequential'
-   */
-  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;
-};
-/**
- * Converts a single file to a string using the registered parsers.
- * Falls back to joining source values when no matching parser is found.
- *
- * @internal
- */
-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>>;
-}
-//#endregion
 //#region src/storages/fsStorage.d.ts
 /**
  * Built-in filesystem storage driver.
@@ -364,12 +188,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>;
-declare function isInputPath(config: Config | undefined): config is Config<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 { Adapter, AdapterFactoryOptions, AdapterSource, AsyncEventEmitter, BuildOutput, CLIOptions, Config, DevtoolsOptions, Exclude, FileManager, FileProcessor, FileProcessorEvents, 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, ResolveOptionsContext, Resolver, ResolverContext, ResolverFileParams, ResolverPathParams, Storage, URLPath, UserConfig, UserLogger, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map