@kubb/core 1.15.0-canary.20231027T200912 → 2.0.0-alpha.2

package/dist/index.d.cts

@@ -1,89 +1,43 @@
 import { DirectoryTreeOptions } from 'directory-tree';
 import { Ora } from 'ora';
-export { default as pc } from 'picocolors';
 
-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 clean(path: string): Promise<void>;
-
-type FunctionParamsASTWithoutType = {
-    name?: string;
-    type?: string;
-    /**
-     * @default true
-     */
-    required?: boolean;
-    /**
-     * @default true
-     */
-    enabled?: boolean;
-    default?: string;
-};
-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 read(path: string): Promise<string>;
 
-declare function getUniqueName(originalName: string, data: Record<string, number>): string;
+declare function write(data: string, path: string): Promise<string | undefined>;
 
-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;
+type BarrelManagerOptions = {
+    treeNode?: DirectoryTreeOptions;
+    isTypeOnly?: boolean;
+    filter?: (file: KubbFile.File) => boolean;
+    map?: (file: KubbFile.File) => KubbFile.File;
+    includeExt?: boolean;
+    output?: string;
 };
 
-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;
+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 QueueJob<T = unknown> = {
-    (...args: unknown[]): Promise<T> | Promise<void>;
+    (...args: unknown[]): Promise<T | 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;
@@ -91,14 +45,7 @@ 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>;
@@ -111,6 +58,10 @@ declare namespace KubbFile {
         isTypeOnly?: boolean;
         asAlias?: boolean;
     };
+    const dataTagSymbol: unique symbol;
+    type DataTag<Type, Value> = Type & {
+        [dataTagSymbol]: Value;
+    };
     type UUID = string;
     type Source = string;
     type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
@@ -119,11 +70,15 @@ declare namespace KubbFile {
     type Path = string;
     type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`;
     type OptionalPath = Path | undefined | null;
-    type File<TMeta extends {
-        pluginName?: string;
-    } = {
-        pluginName?: string;
-    }, TBaseName extends BaseName = BaseName> = {
+    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;
         /**
          * Name to be used to dynamicly create the baseName(based on input.path)
          * Based on UNIX basename
@@ -139,6 +94,7 @@ 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;
@@ -147,22 +103,69 @@ declare namespace KubbFile {
          * This will override `process.env[key]` inside the `source`, see `getFileSource`.
          */
         env?: NodeJS.ProcessEnv;
+        validate?: boolean;
     };
-    type ResolvedFile = KubbFile.File & {
+    type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = KubbFile.File<TMeta, TBaseName> & {
         /**
-         * crypto.randomUUID()
+         * @default 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 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 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 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 SummaryError extends Error {
     summary: string[];
     constructor(message: string, options: {
@@ -170,82 +173,6 @@ 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)
  */
@@ -254,70 +181,28 @@ declare class Warning extends Error {
         cause: 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 class ValidationPluginError extends Error {
 }
 
-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>;
+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[];
 };
-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>;
 /**
@@ -325,9 +210,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 = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
+type Strategy$1 = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-    strategy: Strategy;
+    strategy: Strategy$1;
     hookName: H;
     plugin: KubbPlugin;
     parameters?: unknown[] | undefined;
@@ -338,13 +223,16 @@ 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 = {
-    debug?: boolean;
-    task: QueueJob<KubbFile.ResolvedFile>;
     logger: Logger;
+    /**
+     * Task for the FileManager
+     */
+    task: QueueJob<KubbFile.ResolvedFile>;
+    /**
+     * Timeout between writes in the FileManager
+     */
+    writeTimeout?: number;
 };
 type Events = {
     execute: [executer: Executer];
@@ -366,16 +254,16 @@ declare class PluginManager {
     /**
      * Run only hook for a specific plugin name
      */
-    hookForPlugin<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
-        pluginName: string;
+    hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+        pluginKey: KubbPlugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
-    }): Promise<ReturnType<ParseResult<H>> | null> | null;
-    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
-        pluginName: string;
+    }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
+        pluginKey: KubbPlugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
-    }): ReturnType<ParseResult<H>> | null;
+    }): Array<ReturnType<ParseResult<H>>> | null;
     /**
      * Chains, first non-null result stops and returns
      */
@@ -414,32 +302,17 @@ declare class PluginManager {
         hookName: H;
         parameters?: PluginParameter<H>;
     }): Promise<void>;
-    getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin;
+    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"];
 }
 
-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 {
+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 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`
@@ -461,7 +334,7 @@ type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
      * Example: ['@kubb/swagger', { output: false }]
      * Or: createSwagger({ output: false })
      */
-    plugins?: Array<KubbPlugin> | Array<KubbJSONPlugins> | KubbObjectPlugins;
+    plugins?: Array<Omit<KubbUserPlugin, 'api'> | KubbUnionPlugins | [name: string, options: object]>;
 };
 type InputPath = {
     /**
@@ -479,14 +352,18 @@ type Input = InputPath | InputData;
 /**
  * @private
  */
-type KubbConfig = {
+type KubbConfig<TInput = Input> = {
+    /**
+     * Optional config name to show in CLI output
+     */
+    name?: string;
     /**
      * 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: Input;
+    input: TInput;
     output: {
         /**
          * Path to be used to export all generated files.
@@ -547,40 +424,50 @@ type BuildOutput = {
     pluginManager: PluginManager;
 };
 type KubbPluginKind = 'schema' | 'controller';
-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 KubbUnionPlugins = PluginUnion;
+type KubbObjectPlugin = keyof OptionsPlugins;
+type GetPluginFactoryOptions<TPlugin extends KubbUserPlugin> = TPlugin extends KubbUserPlugin<infer X> ? X : never;
 type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
      * @example @kubb/typescript
      */
-    name: PluginFactoryOptions['name'];
+    name: TOptions['name'];
+    /**
+     * Internal key used when a developer uses more than one of the same plugin
+     * @private
+     */
+    key?: TOptions['key'];
     /**
      * 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?: KubbPluginKind;
-} & Partial<PluginLifecycle<TOptions>> & (TOptions['api'] extends never ? {
-    api?: never;
-} : {
-    api: (this: Omit<PluginContext, 'addFile'>) => TOptions['api'];
+    kind: TOptions['kind'];
 });
 type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
      * @example @kubb/typescript
      */
-    name: PluginFactoryOptions['name'];
-    key?: [kind: KubbPluginKind | undefined, name: PluginFactoryOptions['name'], identifier: string];
+    name: TOptions['name'];
+    /**
+     * Internal key used when a developer uses more than one of the same plugin
+     * @private
+     */
+    key: TOptions['key'];
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
@@ -597,8 +484,13 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
 } : {
     api: TOptions['api'];
 });
-type PluginFactoryOptions<Name = string, Options = unknown | never, Nested extends boolean = false, API = unknown | never, resolvePathOptions = Record<string, unknown>> = {
+type PluginFactoryOptions<Name = string, Kind extends KubbPluginKind = KubbPluginKind | never, 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;
@@ -643,7 +535,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * 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<void>;
+    writeFile?: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise<string | void>;
     /**
      * End of the plugin lifecycle.
      * @type hookParallel
@@ -651,13 +543,10 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
     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>> = {
-    /**
-     * 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;
+    pluginKey?: KubbPlugin['key'];
     baseName: string;
     directory?: string | undefined;
     /**
@@ -667,11 +556,7 @@ type ResolvePathParams<TOptions = Record<string, unknown>> = {
 };
 type ResolveNameParams = {
     name: string;
-    /**
-     * 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;
+    pluginKey?: KubbPlugin['key'];
     type?: 'file' | 'function';
 };
 type PluginContext<TOptions = Record<string, unknown>> = {
@@ -683,22 +568,51 @@ 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<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 BuildOptions = {
     config: PluginContext['config'];
@@ -706,7 +620,6 @@ type BuildOptions = {
      * @default Logger without the spinner
      */
     logger?: Logger;
-    logLevel?: LogLevel;
 };
 declare function build(options: BuildOptions): Promise<BuildOutput>;
 
@@ -715,9 +628,10 @@ 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<KubbUserConfig> | ((
+declare function defineConfig(options: PossiblePromise<KubbUserConfig | Array<KubbUserConfig>> | ((
 /** The options derived from the CLI flags */
-cliOptions: CLIOptions) => PossiblePromise<KubbUserConfig>)): typeof options;
+cliOptions: CLIOptions) => PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>)): typeof options;
+declare function isInputPath(result: KubbConfig | undefined): result is KubbConfig<InputPath>;
 
 /**
  * Abstract class that contains the building blocks for plugins to create their own Generator
@@ -732,6 +646,50 @@ 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 PromiseFunc$1<T = unknown, T2 = never> = (state: T) => T2 extends never ? Promise<T> : Promise<T> | T2;
+type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc$1<infer X, infer Y>> ? X | Y : never;
+type SeqOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Array<Awaited<ValueOfPromiseFuncArray<TInput>>>;
+type HookFirstOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>;
+type Strategy = 'seq' | 'first';
+type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = TStrategy extends 'first' ? HookFirstOutput<TInput, TValue> : TStrategy extends 'seq' ? SeqOutput<TInput, TValue> : never;
+
+type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
+type Options<TState = any> = {
+    nullCheck?: (state: TState) => boolean;
+};
+declare class PromiseManager<TState = any> {
+    #private;
+    constructor(options?: Options<TState>);
+    run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(strategy: TStrategy, promises: TInput): TOutput;
+}
+
 /**
  * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
  */
@@ -739,19 +697,14 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-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;
+interface _Register {
+}
+type Plugins = _Register;
+type OptionsPlugins = {
+    [K in keyof Plugins]: Plugins[K]['options'];
 };
-type CorePluginOptions = PluginFactoryOptions<'core', Options, false, PluginContext>;
-declare const pluginName: CorePluginOptions['name'];
+type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options'];
+type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>;
+type Plugin = keyof Plugins;
 
-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 };
+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, Prettify, PromiseManager, ResolveNameParams, ResolvePathParams, SchemaGenerator, SummaryError, TransformResult, TupleToUnion, ValidationPluginError, Warning, _Register, build, combineExports, combineImports, createPlugin, build as default, defineConfig, isInputPath, pluginName as name, pluginName };