@kubb/core 1.15.0-canary.20231023T125852 → 1.15.0-canary.20231024T104207

package/dist/index.d.cts

@@ -47,8 +47,6 @@ declare class 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'> & {
@@ -61,6 +59,11 @@ declare function createJSDocBlockText({ comments }: {
 
 type LogType = 'error' | 'info' | 'warning';
 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;
@@ -68,22 +71,41 @@ type Logger = {
     spinner?: Ora;
     logs: string[];
 };
-declare function createLogger(spinner?: Ora): Logger;
+type Props = {
+    name?: string;
+    logLevel: LogLevel;
+    spinner?: Ora;
+};
+declare function createLogger({ logLevel, name, spinner }: Props): 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,73 +113,10 @@ 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>;
-        path: string;
-        isTypeOnly?: boolean;
-    };
-    type Export = {
-        name?: string | Array<string>;
-        path: string;
-        isTypeOnly?: boolean;
-        asAlias?: boolean;
-    };
-    type UUID = string;
-    type Source = string;
-    type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-    type Mode = 'file' | 'directory';
-    type BaseName = `${string}${Extname}`;
-    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> = {
-        /**
-         * Name to be used to dynamicly create the baseName(based on input.path)
-         * Based on UNIX basename
-         * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-         */
-        baseName: TBaseName;
-        /**
-         * Path will be full qualified path to a specified file
-         */
-        path: AdvancedPath<TBaseName> | Path;
-        source: Source;
-        imports?: Import[];
-        exports?: Export[];
-        /**
-         * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
-         * @default `false`
-         */
-        override?: boolean;
-        meta?: TMeta;
-        /**
-         * This will override `process.env[key]` inside the `source`, see `getFileSource`.
-         */
-        env?: NodeJS.ProcessEnv;
-    };
-    type ResolvedFile = KubbFile.File & {
-        /**
-         * crypto.randomUUID()
-         */
-        id: UUID;
-    };
-}
-
 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;
 
@@ -185,8 +144,18 @@ declare function escape(text?: string): string;
  */
 declare function jsStringEscape(input: any): string;
 
+declare function createIndent(size: number): string;
+
 declare function transformReservedWord(word: string): string;
 
+declare const transformers: {
+    readonly combineCodes: typeof combineCodes;
+    readonly escape: typeof escape;
+    readonly jsStringEscape: typeof jsStringEscape;
+    readonly createIndent: typeof createIndent;
+    readonly transformReservedWord: typeof transformReservedWord;
+};
+
 type TreeNodeOptions = DirectoryTreeOptions;
 declare class TreeNode<T = unknown> {
     data: T;
@@ -203,6 +172,9 @@ declare class TreeNode<T = unknown> {
 
 declare const uniqueIdFactory: (counter: number) => (str?: string) => string;
 
+declare function getUniqueName(originalName: string, data: Record<string, number>): string;
+declare function setUniqueName(originalName: string, data: Record<string, number>): string;
+
 type URLObject = {
     url: string;
     params?: Record<string, string>;
@@ -255,66 +227,113 @@ declare class Warning extends Error {
     });
 }
 
-declare function write(data: string, path: string): Promise<void>;
+declare function write(data: string, path: string): Promise<string | undefined>;
 
+type BasePath<T extends string = string> = `${T}/`;
+declare namespace KubbFile {
+    type Import = {
+        name: string | Array<string>;
+        path: string;
+        isTypeOnly?: boolean;
+    };
+    type Export = {
+        name?: string | Array<string>;
+        path: string;
+        isTypeOnly?: boolean;
+        asAlias?: boolean;
+    };
+    type UUID = string;
+    type Source = string;
+    type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+    type Mode = 'file' | 'directory';
+    type BaseName = `${string}${Extname}`;
+    type Path = string;
+    type AdvancedPath<T extends BaseName = BaseName> = `${BasePath}${T}`;
+    type OptionalPath = Path | undefined | null;
+    type File<TMeta extends {
+        pluginKey?: KubbPlugin['key'];
+    } = {
+        pluginKey?: KubbPlugin['key'];
+    }, TBaseName extends BaseName = BaseName> = {
+        /**
+         * Name to be used to dynamicly create the baseName(based on input.path)
+         * Based on UNIX basename
+         * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+         */
+        baseName: TBaseName;
+        /**
+         * Path will be full qualified path to a specified file
+         */
+        path: AdvancedPath<TBaseName> | Path;
+        source: Source;
+        imports?: Import[];
+        exports?: Export[];
+        /**
+         * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
+         * @default `false`
+         */
+        override?: boolean;
+        meta?: TMeta;
+        /**
+         * This will override `process.env[key]` inside the `source`, see `getFileSource`.
+         */
+        env?: NodeJS.ProcessEnv;
+    };
+    type ResolvedFile = KubbFile.File & {
+        /**
+         * crypto.randomUUID()
+         */
+        id: UUID;
+    };
+}
+
+type IndexesOptions = {
+    treeNode?: TreeNodeOptions;
+    isTypeOnly?: boolean;
+    filter?: (file: KubbFile.File) => boolean;
+    map?: (file: KubbFile.File) => KubbFile.File;
+    includeExt?: boolean;
+    output?: string;
+};
+
+type AddIndexesProps = {
+    root: KubbFile.Path;
+    extName?: KubbFile.Extname;
+    options?: IndexesOptions;
+    meta?: KubbFile.File['meta'];
+};
+type Options$1 = {
+    queue?: Queue;
+    task?: QueueJob<KubbFile.ResolvedFile>;
+    /**
+     * Timeout between writes
+     */
+    timeout?: number;
+};
 declare class FileManager {
     #private;
-    constructor(options?: {
-        queue?: Queue;
-        task?: QueueJob<KubbFile.ResolvedFile>;
-    });
+    constructor(options?: Options$1);
     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>;
+    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<void>;
+    write(...params: Parameters<typeof write>): Promise<string | undefined>;
     read(...params: Parameters<typeof read>): Promise<string>;
+    static getSource(file: KubbFile.File): string;
+    static combineFiles(files: Array<KubbFile.File | null>): Array<KubbFile.File>;
+    static getMode(path: string | undefined | null): KubbFile.Mode;
 }
 
-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 SeqOutput<TInput extends Array<PromiseFunc<TPromise, null>>, TPromise = unknown> = ReturnType<NonNullable<TInput[number]>>;
+declare function hookSeq<TInput extends Array<PromiseFunc<TPromise, null>>, TPromise = unknown, TOutput = SeqOutput<TInput, TPromise>>(promises: TInput): TOutput;
+declare const executeStrategies: {
+    readonly hookSeq: typeof hookSeq;
 };
-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;
-    getVersion(dependency: string): Promise<string | undefined>;
-    getVersionSync(dependency: string): string | undefined;
-    isValid(dependency: string, version: string): Promise<boolean>;
-    isValidSync(dependency: string, version: string): 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>;
 /**
@@ -337,11 +356,17 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 };
 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>;
+declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<string, KubbPluginKind, unknown, false, unknown, Record<string, unknown>>>];
+type Options = {
     logger: Logger;
+    /**
+     * Task for the FileManager
+     */
+    task: QueueJob<KubbFile.ResolvedFile>;
+    /**
+     * Timeout between writes in the FileManager
+     */
+    writeTimeout?: number;
 };
 type Events = {
     execute: [executer: Executer];
@@ -356,23 +381,24 @@ declare class PluginManager {
     readonly queue: Queue;
     readonly executed: Executer[];
     readonly logger: Logger;
-    constructor(config: KubbConfig, options: Options$1);
+    usedPluginNames: Record<string, number>;
+    constructor(config: KubbConfig, options: Options);
     resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void;
     /**
      * 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
      */
@@ -411,7 +437,7 @@ 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[];
 }
 
 declare class PluginError extends Error {
@@ -458,7 +484,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 = {
     /**
@@ -476,14 +502,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.
@@ -544,40 +574,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.
      */
@@ -594,8 +634,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;
@@ -640,7 +685,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
@@ -650,11 +695,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
 type PluginLifecycleHooks = keyof PluginLifecycle;
 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;
     /**
@@ -664,11 +705,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>> = {
@@ -680,7 +717,14 @@ 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: {
@@ -696,6 +740,13 @@ type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
 type PossiblePromise<T> = Promise<T> | T;
+type PromiseFunc<T, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
+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>;
+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;
+type TupleToUnion<T> = T extends Array<infer ITEMS> ? ITEMS : never;
 
 type BuildOptions = {
     config: PluginContext['config'];
@@ -703,7 +754,6 @@ type BuildOptions = {
      * @default Logger without the spinner
      */
     logger?: Logger;
-    logLevel?: LogLevel;
 };
 declare function build(options: BuildOptions): Promise<BuildOutput>;
 
@@ -712,9 +762,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
@@ -736,19 +787,38 @@ 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>;
+type PackageJSON = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, 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;
+    getVersion(dependency: string): Promise<string | undefined>;
+    getVersionSync(dependency: string): string | undefined;
+    isValid(dependency: string, version: string): Promise<boolean>;
+    isValidSync(dependency: string, version: string): 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>>;
-type Options = {
-    config: PluginContext['config'];
-    fileManager: FileManager;
-    pluginManager: PluginManager;
-    resolvePath: PluginContext['resolvePath'];
-    resolveName: PluginContext['resolveName'];
-    logger: PluginContext['logger'];
-    getPlugins: () => KubbPlugin[];
-    plugin: KubbPlugin;
+declare const pluginName = "core";
+
+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, Cache, FileManager, FunctionParams, FunctionParamsAST, Generator, GetPluginFactoryOptions, InputData, InputPath, KubbConfig, KubbFile, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUnionPlugins, KubbUserConfig, KubbUserPlugin, LogLevel, LogType, Logger, ObjValueTuple, OptionsOfPlugin, OptionsPlugins, PackageManager, ParallelPluginError, Plugin, PluginCache, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginUnion, Plugins, PossiblePromise, Prettify, PromiseFunc, Queue, QueueJob, ResolveNameParams, ResolvePathParams, SchemaGenerator, SummaryError, TransformResult, TreeNode, TreeNodeOptions, TupleToUnion, URLObject, URLPath, ValidationPluginError, Warning, _Register, build, clean, createJSDocBlockText, createLogger, createPlugin, createPluginCache, build as default, defineConfig, executeStrategies, getDependedPlugins, getRelativePath, getUniqueName, hooks, isInputPath, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, pluginName as name, nameSorter, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, setUniqueName, throttle, timeout, transformers, uniqueIdFactory, write };