@kubb/core 1.15.0-canary.20231025T223729 → 1.15.0-canary.20231026T165002

package/dist/index.d.ts

@@ -1,43 +1,89 @@
 import { DirectoryTreeOptions } from 'directory-tree';
 import { Ora } from 'ora';
+export { default as pc } from 'picocolors';
 
-declare function read(path: string): Promise<string>;
+interface Cache<TStore extends object = object> {
+    delete(id: keyof TStore): boolean;
+    get(id: keyof TStore): TStore[keyof TStore] | null;
+    has(id: keyof TStore): boolean;
+    set(id: keyof TStore, value: unknown): void;
+}
+declare function createPluginCache<TStore extends PluginCache>(Store?: TStore): Cache<TStore>;
 
-declare function write(data: string, path: string): Promise<string | undefined>;
+declare function clean(path: string): Promise<void>;
 
-type BarrelManagerOptions = {
-    treeNode?: DirectoryTreeOptions;
-    isTypeOnly?: boolean;
-    filter?: (file: KubbFile.File) => boolean;
-    map?: (file: KubbFile.File) => KubbFile.File;
-    includeExt?: boolean;
-    output?: string;
+type FunctionParamsASTWithoutType = {
+    name?: string;
+    type?: string;
+    /**
+     * @default true
+     */
+    required?: boolean;
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    default?: string;
 };
-
-declare class EventEmitter<TEvents extends Record<string, any>> {
-    #private;
-    constructor();
-    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
-    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    removeAll(): void;
+type FunctionParamsASTWithType = {
+    name?: never;
+    type: string;
+    /**
+     * @default true
+     */
+    required?: boolean;
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    default?: string;
+};
+type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
+declare class FunctionParams {
+    type?: 'generics' | 'typed';
+    items: FunctionParamsAST[];
+    constructor(type?: 'generics' | 'typed');
+    add(item: FunctionParamsAST | Array<FunctionParamsAST | undefined> | undefined): FunctionParams;
+    toString(): string;
 }
 
+declare function getUniqueName(originalName: string, data: Record<string, number>): string;
+
+declare function isPromise<T>(result: PossiblePromise<T>): result is Promise<T>;
+declare function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T>;
+declare function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & {
+    reason: T;
+};
+
+declare function createJSDocBlockText({ comments }: {
+    comments: Array<string>;
+}): string;
+
+type LogType = 'error' | 'info' | 'warning';
+type Logger = {
+    log: (message: string | null) => void;
+    error: (message: string | null) => void;
+    info: (message: string | null) => void;
+    warn: (message: string | null) => void;
+    spinner?: Ora;
+    logs: string[];
+};
+declare function createLogger(spinner?: Ora): Logger;
+
+declare function nameSorter<T extends {
+    name: string;
+}>(a: T, b: T): 0 | 1 | -1;
+
 type QueueJob<T = unknown> = {
-    (...args: unknown[]): Promise<T | void>;
+    (...args: unknown[]): Promise<T> | Promise<void>;
 };
 type RunOptions = {
     controller?: AbortController;
     name?: string;
     description?: string;
 };
-type Events$1 = {
-    jobDone: [result: unknown];
-    jobFailed: [error: Error];
-};
 declare class Queue {
     #private;
-    readonly eventEmitter: EventEmitter<Events$1>;
     constructor(maxParallel: number, debug?: boolean);
     run<T>(job: QueueJob<T>, options?: RunOptions): Promise<T>;
     runSync<T>(job: QueueJob<T>, options?: RunOptions): void;
@@ -45,7 +91,14 @@ declare class Queue {
     get count(): number;
 }
 
+declare const defaultColours: readonly ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
+declare function randomColour(text?: string, colours?: readonly ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"]): string;
+declare function randomPicoColour(text?: string, colors?: readonly ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"]): string;
+
 type BasePath<T extends string = string> = `${T}/`;
+type CacheItem = KubbFile.ResolvedFile & {
+    cancel?: () => void;
+};
 declare namespace KubbFile {
     type Import = {
         name: string | Array<string>;
@@ -66,15 +119,11 @@ declare namespace KubbFile {
     type Path = string;
     type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`;
     type OptionalPath = Path | undefined | null;
-    type FileMetaBase = {
-        pluginKey?: KubbPlugin['key'];
-    };
-    type File<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = {
-        /**
-         * Unique identifier to reuse later
-         * @default crypto.randomUUID()
-         */
-        id?: string;
+    type File<TMeta extends {
+        pluginName?: string;
+    } = {
+        pluginName?: string;
+    }, TBaseName extends BaseName = BaseName> = {
         /**
          * Name to be used to dynamicly create the baseName(based on input.path)
          * Based on UNIX basename
@@ -90,7 +139,6 @@ declare namespace KubbFile {
         exports?: Export[];
         /**
          * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
-         * This will also ignore the combinefiles utils
          * @default `false`
          */
         override?: boolean;
@@ -99,67 +147,22 @@ declare namespace KubbFile {
          * This will override `process.env[key]` inside the `source`, see `getFileSource`.
          */
         env?: NodeJS.ProcessEnv;
-        validate?: boolean;
     };
     type ResolvedFile = KubbFile.File & {
         /**
-         * @default crypto.randomUUID()
+         * crypto.randomUUID()
          */
         id: UUID;
     };
 }
-type AddResult<T extends Array<KubbFile.File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<KubbFile.ResolvedFile[]> : Promise<KubbFile.ResolvedFile>>>;
-type AddIndexesProps = {
-    root: KubbFile.Path;
-    extName?: KubbFile.Extname;
-    options?: BarrelManagerOptions;
-    meta?: KubbFile.File['meta'];
-};
-type Options$2 = {
-    queue?: Queue;
-    task?: QueueJob<KubbFile.ResolvedFile>;
-    /**
-     * Timeout between writes
-     */
-    timeout?: number;
-};
-declare class FileManager {
-    #private;
-    constructor(options?: Options$2);
-    get files(): Array<KubbFile.File>;
-    get isExecuting(): boolean;
-    add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T>;
-    addIndexes({ root, extName, meta, options }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined>;
-    getCacheByUUID(UUID: KubbFile.UUID): KubbFile.File | undefined;
-    get(path: KubbFile.Path): Array<KubbFile.File> | undefined;
-    remove(path: KubbFile.Path): void;
-    write(...params: Parameters<typeof write>): Promise<string | undefined>;
-    read(...params: Parameters<typeof read>): Promise<string>;
-    static getSource<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(file: KubbFile.File<TMeta>): string;
-    static combineFiles<TMeta extends KubbFile.FileMetaBase = KubbFile.FileMetaBase>(files: Array<KubbFile.File<TMeta> | null>): Array<KubbFile.File<TMeta>>;
-    static getMode(path: string | undefined | null): KubbFile.Mode;
-    static get extensions(): Array<KubbFile.Extname>;
-    static isExtensionAllowed(baseName: string): boolean;
-}
 
-declare class PluginError extends Error {
-    pluginManager: PluginManager;
-    cause: Error;
-    constructor(message: string, options: {
-        cause: Error;
-        pluginManager: PluginManager;
-    });
-}
-declare class ParallelPluginError extends Error {
-    errors: PluginError[];
-    pluginManager: PluginManager;
-    constructor(message: string, options: {
-        cause?: Error;
-        errors: PluginError[];
-        pluginManager: PluginManager;
-    });
-    findError<T extends Error = Error>(searchError: T | undefined): T | undefined;
-}
+declare function getRelativePath(rootDir?: string | null, filePath?: string | null, platform?: 'windows' | 'mac' | 'linux'): string;
+declare function getPathMode(path: string | undefined | null): KubbFile.Mode;
+declare function read(path: string): Promise<string>;
+declare function readSync(path: string): string;
+
+declare function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data?: TData | undefined): string;
+
 declare class SummaryError extends Error {
     summary: string[];
     constructor(message: string, options: {
@@ -167,6 +170,82 @@ declare class SummaryError extends Error {
         summary?: string[];
     });
 }
+
+declare const throttle: <R, A extends any[]>(fn: (...args: A) => R, delay: number) => [(...args: A) => R | undefined, () => void];
+
+declare function timeout(ms: number): Promise<unknown>;
+
+declare function combineCodes(codes: string[]): string;
+
+declare function escape(text?: string): string;
+/**
+ * Escape all characters not included in SingleStringCharacters and DoubleStringCharacters on
+ * @link http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+ * @link https://github.com/joliss/js-string-escape/blob/master/index.js
+ */
+declare function jsStringEscape(input: any): string;
+
+declare function transformReservedWord(word: string): string;
+
+type TreeNodeOptions = DirectoryTreeOptions;
+declare class TreeNode<T = unknown> {
+    data: T;
+    parent?: TreeNode<T>;
+    children: Array<TreeNode<T>>;
+    constructor(data: T, parent?: TreeNode<T>);
+    addChild(data: T): TreeNode<T>;
+    find(data?: T): TreeNode<T> | null;
+    get leaves(): TreeNode<T>[];
+    get root(): TreeNode<T>;
+    forEach(callback: (treeNode: TreeNode<T>) => void): this;
+    static build<T = unknown>(path: string, options?: TreeNodeOptions): TreeNode<T> | null;
+}
+
+declare const uniqueIdFactory: (counter: number) => (str?: string) => string;
+
+type URLObject = {
+    url: string;
+    params?: Record<string, string>;
+};
+type ObjectOptions = {
+    type?: 'path' | 'template';
+    replacer?: (pathParam: string) => string;
+    stringify?: boolean;
+};
+declare class URLPath {
+    path: string;
+    constructor(path: string);
+    /**
+     * Convert Swagger path to URLPath(syntax of Express)
+     * @example /pet/{petId} => /pet/:petId
+     */
+    get URL(): string;
+    get isURL(): boolean;
+    /**
+     * Convert Swagger path to template literals/ template strings(camelcase)
+     * @example /pet/{petId} => `/pet/${petId}`
+     * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+     * @example /account/userID => `/account/${userId}`
+     */
+    get template(): string;
+    get object(): URLObject | string;
+    get params(): Record<string, string> | undefined;
+    toObject({ type, replacer, stringify }?: ObjectOptions): URLObject | string;
+    /**
+     * Convert Swagger path to template literals/ template strings(camelcase)
+     * @example /pet/{petId} => `/pet/${petId}`
+     * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
+     * @example /account/userID => `/account/${userId}`
+     */
+    toTemplateString(replacer?: (pathParam: string) => string): string;
+    getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined;
+    /**
+     * Convert Swagger path to URLPath(syntax of Express)
+     * @example /pet/{petId} => /pet/:petId
+     */
+    toURLPath(): string;
+}
+
 /**
  * Behaves as an Error to log a warning in the console(still stops the execution)
  */
@@ -175,28 +254,70 @@ declare class Warning extends Error {
         cause: Error;
     });
 }
-declare class ValidationPluginError extends Error {
+
+declare function write(data: string, path: string): Promise<void>;
+
+declare class FileManager {
+    #private;
+    constructor(options?: {
+        queue?: Queue;
+        task?: QueueJob<KubbFile.ResolvedFile>;
+    });
+    get extensions(): Array<KubbFile.Extname>;
+    get files(): Array<KubbFile.File>;
+    get isExecuting(): boolean;
+    add(file: KubbFile.File): Promise<KubbFile.ResolvedFile>;
+    addOrAppend(file: KubbFile.File): Promise<KubbFile.ResolvedFile>;
+    addIndexes(root: KubbFile.Path, extName?: KubbFile.Extname, options?: TreeNodeOptions): Promise<Array<KubbFile.File> | undefined>;
+    getCacheByUUID(UUID: KubbFile.UUID): KubbFile.File | undefined;
+    get(path: KubbFile.Path): Array<KubbFile.File> | undefined;
+    remove(path: KubbFile.Path): void;
+    write(...params: Parameters<typeof write>): Promise<void>;
+    read(...params: Parameters<typeof read>): Promise<string>;
 }
 
-declare const LogLevel: {
-    readonly silent: "silent";
-    readonly info: "info";
-    readonly debug: "debug";
-};
-type LogLevel = keyof typeof LogLevel;
-type Logger = {
-    /**
-     * Optional config name to show in CLI output
-     */
-    name?: string;
-    logLevel: LogLevel;
-    log: (message: string | null) => void;
-    error: (message: string | null) => void;
-    info: (message: string | null) => void;
-    warn: (message: string | null) => void;
-    spinner?: Ora;
-    logs: string[];
+declare function getIndexes(root: string, extName?: KubbFile.Extname, options?: TreeNodeOptions): Array<KubbFile.File> | null;
+declare function combineFiles(files: Array<KubbFile.File | null>): Array<KubbFile.File>;
+/**
+ * Support for js, ts and tsx(React)
+ */
+declare const extensions: Array<KubbFile.Extname>;
+declare function isExtensionAllowed(baseName: string): boolean;
+declare function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile.Export>;
+declare function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source: string): Array<KubbFile.Import>;
+declare function createFileSource(file: KubbFile.File): string;
+
+type PackageJSON = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
 };
+type DependencyName = string;
+type DependencyVersion = string;
+declare class PackageManager {
+    #private;
+    constructor(workspace?: string);
+    set workspace(workspace: string);
+    get workspace(): string | undefined;
+    normalizeDirectory(directory: string): string;
+    getLocation(path: string): string;
+    import(path: string): Promise<any | undefined>;
+    getPackageJSON(): Promise<PackageJSON | undefined>;
+    getPackageJSONSync(): PackageJSON | undefined;
+    static setVersion(dependency: DependencyName, version: DependencyVersion): void;
+    getVersion(dependency: DependencyName): Promise<DependencyVersion | undefined>;
+    getVersionSync(dependency: DependencyName): DependencyVersion | undefined;
+    isValid(dependency: DependencyName, version: DependencyVersion): Promise<boolean>;
+    isValidSync(dependency: DependencyName, version: DependencyVersion): boolean;
+}
+
+declare class EventEmitter<TEvents extends Record<string, any>> {
+    #private;
+    constructor();
+    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
+    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+    off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+    removeAll(): void;
+}
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>;
 /**
@@ -204,9 +325,9 @@ type RequiredPluginLifecycle = Required<PluginLifecycle>;
  * @example Arg0<(a: string, b: number) => void> -> string
  */
 type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
-type Strategy$1 = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
+type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-    strategy: Strategy$1;
+    strategy: Strategy;
     hookName: H;
     plugin: KubbPlugin;
     parameters?: unknown[] | undefined;
@@ -217,16 +338,13 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
     result: Result;
     plugin: KubbPlugin;
 };
+type PluginParameter<H extends PluginLifecycleHooks> = Parameters<RequiredPluginLifecycle[H]>;
+
+declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<string, unknown, false, unknown, Record<string, unknown>>>];
 type Options$1 = {
-    logger: Logger;
-    /**
-     * Task for the FileManager
-     */
+    debug?: boolean;
     task: QueueJob<KubbFile.ResolvedFile>;
-    /**
-     * Timeout between writes in the FileManager
-     */
-    writeTimeout?: number;
+    logger: Logger;
 };
 type Events = {
     execute: [executer: Executer];
@@ -248,16 +366,16 @@ declare class PluginManager {
     /**
      * Run only hook for a specific plugin name
      */
-    hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
-        pluginKey: KubbPlugin['key'];
+    hookForPlugin<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
         hookName: H;
         parameters: PluginParameter<H>;
-    }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
-    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
-        pluginKey: KubbPlugin['key'];
+    }): Promise<ReturnType<ParseResult<H>> | null> | null;
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
         hookName: H;
         parameters: PluginParameter<H>;
-    }): Array<ReturnType<ParseResult<H>>> | null;
+    }): ReturnType<ParseResult<H>> | null;
     /**
      * Chains, first non-null result stops and returns
      */
@@ -287,7 +405,7 @@ declare class PluginManager {
     hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
         hookName: H;
         parameters: PluginParameter<H>;
-        reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => PossiblePromise$1<Argument0<H> | null>;
+        reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => PossiblePromise<Argument0<H> | null>;
     }): Promise<Argument0<H>>;
     /**
      * Chains plugins
@@ -296,18 +414,33 @@ declare class PluginManager {
         hookName: H;
         parameters?: PluginParameter<H>;
     }): Promise<void>;
-    getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: KubbPlugin['key']): KubbPlugin[];
-    static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = T3 extends never ? T2 extends never ? [T1: KubbPlugin<T1>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>, T3: KubbPlugin<T3>]>(plugins: Array<KubbPlugin>, dependedPluginNames: string | string[]): TOutput;
-    static get hooks(): readonly ["validate", "buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+    getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin;
 }
 
-interface Cache<TStore extends object = object> {
-    delete(id: keyof TStore): boolean;
-    get(id: keyof TStore): TStore[keyof TStore] | null;
-    has(id: keyof TStore): boolean;
-    set(id: keyof TStore, value: unknown): void;
+declare class PluginError extends Error {
+    pluginManager: PluginManager;
+    cause: Error;
+    constructor(message: string, options: {
+        cause: Error;
+        pluginManager: PluginManager;
+    });
+}
+
+declare class ParallelPluginError extends Error {
+    errors: PluginError[];
+    pluginManager: PluginManager;
+    constructor(message: string, options: {
+        cause?: Error;
+        errors: PluginError[];
+        pluginManager: PluginManager;
+    });
+    findError<T extends Error = Error>(searchError: T | undefined): T | undefined;
 }
 
+declare class ValidationPluginError extends Error {
+}
+declare function getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = T3 extends never ? T2 extends never ? [T1: KubbPlugin<T1>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>, T3: KubbPlugin<T3>]>(plugins: Array<KubbPlugin>, dependedPluginNames: string | string[]): TOutput;
+
 /**
  * Config used in `kubb.config.js`
  *
@@ -328,7 +461,7 @@ type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
      * Example: ['@kubb/swagger', { output: false }]
      * Or: createSwagger({ output: false })
      */
-    plugins?: Array<Omit<KubbUserPlugin, 'api'> | KubbUnionPlugins | [name: string, options: object]>;
+    plugins?: Array<KubbPlugin> | Array<KubbJSONPlugins> | KubbObjectPlugins;
 };
 type InputPath = {
     /**
@@ -346,18 +479,14 @@ type Input = InputPath | InputData;
 /**
  * @private
  */
-type KubbConfig<TInput = Input> = {
-    /**
-     * Optional config name to show in CLI output
-     */
-    name?: string;
+type KubbConfig = {
     /**
      * Project root directory. Can be an absolute path, or a path relative from
      * the location of the config file itself.
      * @default process.cwd()
      */
     root: string;
-    input: TInput;
+    input: Input;
     output: {
         /**
          * Path to be used to export all generated files.
@@ -418,50 +547,40 @@ type BuildOutput = {
     pluginManager: PluginManager;
 };
 type KubbPluginKind = 'schema' | 'controller';
-type KubbUnionPlugins = PluginUnion;
-type KubbObjectPlugin = keyof OptionsPlugins;
-type GetPluginFactoryOptions<TPlugin extends KubbUserPlugin> = TPlugin extends KubbUserPlugin<infer X> ? X : never;
+type KubbJSONPlugins = [plugin: keyof Kubb.OptionsPlugins | (string & {}), options: Kubb.OptionsPlugins[keyof Kubb.OptionsPlugins]];
+type KubbObjectPlugin = keyof Kubb.OptionsPlugins;
+type KubbObjectPlugins = {
+    [K in keyof Kubb.OptionsPlugins]: Kubb.OptionsPlugins[K] | object;
+};
 type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
      * @example @kubb/typescript
      */
-    name: TOptions['name'];
-    /**
-     * Internal key used when a developer uses more than one of the same plugin
-     * @private
-     */
-    key?: TOptions['key'];
+    name: PluginFactoryOptions['name'];
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
     options: TOptions['options'] extends never ? undefined : TOptions['options'];
-} & Partial<PluginLifecycle<TOptions>> & (TOptions['api'] extends never ? {
-    api?: never;
-} : {
-    api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext, 'addFile'>) => TOptions['api'];
-}) & (TOptions['kind'] extends never ? {
-    kind?: never;
-} : {
     /**
      * Kind/type for the plugin
      * Type 'schema' can be used for JSON schema's, TypeScript types, ...
      * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
      * @default undefined
      */
-    kind: TOptions['kind'];
+    kind?: KubbPluginKind;
+} & Partial<PluginLifecycle<TOptions>> & (TOptions['api'] extends never ? {
+    api?: never;
+} : {
+    api: (this: Omit<PluginContext, 'addFile'>) => TOptions['api'];
 });
 type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
      * @example @kubb/typescript
      */
-    name: TOptions['name'];
-    /**
-     * Internal key used when a developer uses more than one of the same plugin
-     * @private
-     */
-    key: TOptions['key'];
+    name: PluginFactoryOptions['name'];
+    key?: [kind: KubbPluginKind | undefined, name: PluginFactoryOptions['name'], identifier: string];
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
@@ -478,13 +597,8 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
 } : {
     api: TOptions['api'];
 });
-type PluginFactoryOptions<Name = string, Kind extends KubbPluginKind = KubbPluginKind | never, Options = unknown | never, Nested extends boolean = false, API = unknown | never, resolvePathOptions = Record<string, unknown>> = {
+type PluginFactoryOptions<Name = string, Options = unknown | never, Nested extends boolean = false, API = unknown | never, resolvePathOptions = Record<string, unknown>> = {
     name: Name;
-    kind: Kind;
-    /**
-     * Same like `QueryKey` in `@tanstack/react-query`
-     */
-    key: [kind: Kind | undefined, name: Name, identifier?: string | number];
     options: Options;
     nested: Nested;
     api: API;
@@ -495,12 +609,12 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * Valdiate all plugins to see if their depended plugins are installed and configured.
      * @type hookParallel
      */
-    validate?: (this: Omit<PluginContext, 'addFile'>, plugins: NonNullable<KubbConfig['plugins']>) => PossiblePromise$1<true>;
+    validate?: (this: Omit<PluginContext, 'addFile'>, plugins: NonNullable<KubbConfig['plugins']>) => PossiblePromise<true>;
     /**
      * Start of the lifecycle of a plugin.
      * @type hookParallel
      */
-    buildStart?: (this: PluginContext, kubbConfig: KubbConfig) => PossiblePromise$1<void>;
+    buildStart?: (this: PluginContext, kubbConfig: KubbConfig) => PossiblePromise<void>;
     /**
      * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
      * Options can als be included.
@@ -519,28 +633,31 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * Makes it possible to run async logic to override the path defined previously by `resolvePath`.
      * @type hookFirst
      */
-    load?: (this: Omit<PluginContext, 'addFile'>, path: KubbFile.Path) => PossiblePromise$1<TransformResult | null>;
+    load?: (this: Omit<PluginContext, 'addFile'>, path: KubbFile.Path) => PossiblePromise<TransformResult | null>;
     /**
      * Transform the source-code.
      * @type hookReduceArg0
      */
-    transform?: (this: Omit<PluginContext, 'addFile'>, source: string, path: KubbFile.Path) => PossiblePromise$1<TransformResult>;
+    transform?: (this: Omit<PluginContext, 'addFile'>, source: string, path: KubbFile.Path) => PossiblePromise<TransformResult>;
     /**
      * Write the result to the file-system based on the id(defined by `resolvePath` or changed by `load`).
      * @type hookParallel
      */
-    writeFile?: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise$1<string | void>;
+    writeFile?: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise<void>;
     /**
      * End of the plugin lifecycle.
      * @type hookParallel
      */
-    buildEnd?: (this: PluginContext) => PossiblePromise$1<void>;
+    buildEnd?: (this: PluginContext) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
-type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>;
 type PluginCache = Record<string, [number, unknown]>;
 type ResolvePathParams<TOptions = Record<string, unknown>> = {
-    pluginKey?: KubbPlugin['key'];
+    /**
+     * When set, resolvePath will only call resolvePath of the name of the plugin set here.
+     * If not defined it will fall back on the resolvePath of the core plugin.
+     */
+    pluginName?: string;
     baseName: string;
     directory?: string | undefined;
     /**
@@ -550,7 +667,11 @@ type ResolvePathParams<TOptions = Record<string, unknown>> = {
 };
 type ResolveNameParams = {
     name: string;
-    pluginKey?: KubbPlugin['key'];
+    /**
+     * When set, resolvePath will only call resolvePath of the name of the plugin set here.
+     * If not defined it will fall back on the resolvePath of the core plugin.
+     */
+    pluginName?: string;
     type?: 'file' | 'function';
 };
 type PluginContext<TOptions = Record<string, unknown>> = {
@@ -562,51 +683,22 @@ type PluginContext<TOptions = Record<string, unknown>> = {
     resolvePath: (params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     logger: Logger;
-    /**
-     * All plugins
-     */
     plugins: KubbPlugin[];
-    /**
-     * Current plugin
-     */
-    plugin: KubbPlugin;
 };
 type TransformResult = string | null;
+declare const LogLevel: {
+    readonly silent: "silent";
+    readonly info: "info";
+    readonly debug: "debug";
+};
+type LogLevel = keyof typeof LogLevel;
 type AppMeta = {
     pluginManager: PluginManager;
 };
 type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-/**
- * TODO move to @kubb/types
- * @deprecated
- */
-type PossiblePromise$1<T> = Promise<T> | T;
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
-type Push<T extends any[], V> = [...T, V];
-type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
-/**
- * TODO move to @kubb/types
- * @deprecated
- */
-type ObjValueTuple<T, KS extends any[] = TuplifyUnion<keyof T>, R extends any[] = []> = KS extends [infer K, ...infer KT] ? ObjValueTuple<T, KT, [...R, [name: K & keyof T, options: T[K & keyof T]]]> : R;
-/**
- * TODO move to @kubb/types
- * @deprecated
- */
-type TupleToUnion<T> = T extends Array<infer ITEMS> ? ITEMS : never;
-/**
- * TODO move to @kubb/types
- * @deprecated
- */
-type ArrayWithLength<T extends number, U extends any[] = []> = U['length'] extends T ? U : ArrayWithLength<T, [true, ...U]>;
-/**
- * TODO move to @kubb/types
- * @deprecated
- */
-type GreaterThan<T extends number, U extends number> = ArrayWithLength<U> extends [...ArrayWithLength<T>, ...infer _] ? false : true;
+type PossiblePromise<T> = Promise<T> | T;
 
 type BuildOptions = {
     config: PluginContext['config'];
@@ -614,6 +706,7 @@ type BuildOptions = {
      * @default Logger without the spinner
      */
     logger?: Logger;
+    logLevel?: LogLevel;
 };
 declare function build(options: BuildOptions): Promise<BuildOutput>;
 
@@ -622,10 +715,9 @@ declare function build(options: BuildOptions): Promise<BuildOutput>;
  * accepts a direct {@link KubbConfig} object, or a function that returns it.
  * The function receives a {@link ConfigEnv} object that exposes two properties:
  */
-declare function defineConfig(options: PossiblePromise$1<KubbUserConfig | Array<KubbUserConfig>> | ((
+declare function defineConfig(options: PossiblePromise<KubbUserConfig> | ((
 /** The options derived from the CLI flags */
-cliOptions: CLIOptions) => PossiblePromise$1<KubbUserConfig | Array<KubbUserConfig>>)): typeof options;
-declare function isInputPath(result: KubbConfig | undefined): result is KubbConfig<InputPath>;
+cliOptions: CLIOptions) => PossiblePromise<KubbUserConfig>)): typeof options;
 
 /**
  * Abstract class that contains the building blocks for plugins to create their own Generator
@@ -640,49 +732,6 @@ declare abstract class Generator<TOptions = unknown, TContext = unknown> {
     abstract build(...params: unknown[]): unknown;
 }
 
-type PackageJSON = {
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-};
-type DependencyName = string;
-type DependencyVersion = string;
-declare class PackageManager {
-    #private;
-    constructor(workspace?: string);
-    set workspace(workspace: string);
-    get workspace(): string | undefined;
-    normalizeDirectory(directory: string): string;
-    getLocation(path: string): string;
-    import(path: string): Promise<any | undefined>;
-    getPackageJSON(): Promise<PackageJSON | undefined>;
-    getPackageJSONSync(): PackageJSON | undefined;
-    static setVersion(dependency: DependencyName, version: DependencyVersion): void;
-    getVersion(dependency: DependencyName): Promise<DependencyVersion | undefined>;
-    getVersionSync(dependency: DependencyName): DependencyVersion | undefined;
-    isValid(dependency: DependencyName, version: DependencyVersion): Promise<boolean>;
-    isValidSync(dependency: DependencyName, version: DependencyVersion): boolean;
-}
-
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPlugin<T>;
-declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => ReturnType<KubbPluginFactory<T>>;
-declare const pluginName = "core";
-
-type PossiblePromise<T> = Promise<T> | T;
-type PromiseFunc<T, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
-type SeqOutput<TInput extends Array<PromiseFunc<TPromise, null>>, TPromise = unknown> = ReturnType<NonNullable<TInput[number]>>;
-type Options = {};
-type Strategy = 'seq';
-declare class PromiseManager {
-    #private;
-    constructor(options?: Options);
-    run<TInput extends Array<PromiseFunc<TPromise, null>>, TPromise = unknown, TOutput = SeqOutput<TInput, TPromise>>(strategy: Strategy, promises: TInput): TOutput;
-}
-declare function isPromise<T>(result: PossiblePromise<T>): result is Promise<T>;
-declare function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T>;
-declare function isPromiseRejectedResult<T>(result: PromiseSettledResult<unknown>): result is Omit<PromiseRejectedResult, 'reason'> & {
-    reason: T;
-};
-
 /**
  * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
  */
@@ -690,14 +739,19 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-interface _Register {
-}
-type Plugins = _Register;
-type OptionsPlugins = {
-    [K in keyof Plugins]: Plugins[K]['options'];
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbUserPlugin<T>> : KubbUserPlugin<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => ReturnType<KubbPluginFactory<T>>;
+type Options = {
+    config: PluginContext['config'];
+    fileManager: FileManager;
+    pluginManager: PluginManager;
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
+    logger: PluginContext['logger'];
+    getPlugins: () => KubbPlugin[];
+    plugin: KubbPlugin;
 };
-type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options'];
-type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>;
-type Plugin = keyof Plugins;
+type CorePluginOptions = PluginFactoryOptions<'core', Options, false, PluginContext>;
+declare const pluginName: CorePluginOptions['name'];
 
-export { AppMeta, BuildOutput, CLIOptions, FileManager, Generator, GetPluginFactoryOptions, GreaterThan, InputData, InputPath, KubbConfig, KubbFile, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUnionPlugins, KubbUserConfig, KubbUserPlugin, ObjValueTuple, OptionsOfPlugin, OptionsPlugins, PackageManager, ParallelPluginError, Plugin, PluginCache, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginUnion, Plugins, PossiblePromise$1 as PossiblePromise, Prettify, PromiseManager, ResolveNameParams, ResolvePathParams, SchemaGenerator, SummaryError, TransformResult, TupleToUnion, ValidationPluginError, Warning, _Register, build, createPlugin, build as default, defineConfig, isInputPath, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, pluginName };
+export { AppMeta, Argument0, BuildOutput, CLIOptions, Cache, CacheItem, Executer, FileManager, FunctionParams, FunctionParamsAST, Generator, KubbConfig, KubbFile, KubbJSONPlugins, KubbObjectPlugin, KubbObjectPlugins, KubbPlugin, KubbPluginKind, KubbUserConfig, KubbUserPlugin, LogLevel, LogType, Logger, PackageManager, ParallelPluginError, ParseResult, PluginCache, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PossiblePromise, Prettify, Queue, QueueJob, RequiredPluginLifecycle, ResolveNameParams, ResolvePathParams, SafeParseResult, SchemaGenerator, Strategy, SummaryError, TransformResult, TreeNode, TreeNodeOptions, URLObject, URLPath, ValidationPluginError, Warning, build, clean, combineCodes, combineExports, combineFiles, combineImports, createFileSource, createJSDocBlockText, createLogger, createPlugin, createPluginCache, build as default, defaultColours, defineConfig, escape, extensions, getDependedPlugins, getIndexes, getPathMode, getRelativePath, getUniqueName, hooks, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };