@kubb/core 2.0.0-canary.20231030T124958 → 2.0.0

package/dist/index.d.ts

@@ -1,17 +1,17 @@
+import PQueue from 'p-queue';
+import { w as write, r as read } from './write-A6VgHkYA.js';
+import { PossiblePromise, GreaterThan, TupleToUnion, ObjValueTuple } from '@kubb/types';
 import { DirectoryTreeOptions } from 'directory-tree';
-import { Ora } from 'ora';
-
-declare function read(path: string): Promise<string>;
-
-declare function write(data: string, path: string): Promise<string | undefined>;
+import { Logger, LogLevel } from './logger.js';
+import 'ora';
 
 type BarrelManagerOptions = {
     treeNode?: DirectoryTreeOptions;
     isTypeOnly?: boolean;
-    filter?: (file: KubbFile.File) => boolean;
-    map?: (file: KubbFile.File) => KubbFile.File;
-    includeExt?: boolean;
-    output?: string;
+    /**
+     * Add .ts or .js
+     */
+    extName?: KubbFile.Extname;
 };
 
 declare class EventEmitter<TEvents extends Record<string, any>> {
@@ -23,187 +23,6 @@ declare class EventEmitter<TEvents extends Record<string, any>> {
     removeAll(): void;
 }
 
-type QueueJob<T = unknown> = {
-    (...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;
-    get hasJobs(): boolean;
-    get count(): number;
-}
-
-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;
-    };
-    const dataTagSymbol: unique symbol;
-    type DataTag<Type, Value> = Type & {
-        [dataTagSymbol]: Value;
-    };
-    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 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
-         * @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
-         * This will also ignore the combinefiles utils
-         * @default `false`
-         */
-        override?: boolean;
-        meta?: TMeta;
-        /**
-         * This will override `process.env[key]` inside the `source`, see `getFileSource`.
-         */
-        env?: NodeJS.ProcessEnv;
-        validate?: boolean;
-    };
-    type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = KubbFile.File<TMeta, TBaseName> & {
-        /**
-         * @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 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: {
-        cause: Error;
-        summary?: string[];
-    });
-}
-/**
- * Behaves as an Error to log a warning in the console(still stops the execution)
- */
-declare class Warning extends Error {
-    constructor(message?: string, options?: {
-        cause: Error;
-    });
-}
-declare class ValidationPluginError extends Error {
-}
-
-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 RequiredPluginLifecycle = Required<PluginLifecycle>;
 /**
  * Get the type of the first argument in a function.
@@ -223,49 +42,52 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
     result: Result;
     plugin: KubbPlugin;
 };
-type Options$1 = {
+type Options$2 = {
     logger: Logger;
     /**
      * Task for the FileManager
      */
-    task: QueueJob<KubbFile.ResolvedFile>;
-    /**
-     * Timeout between writes in the FileManager
-     */
-    writeTimeout?: number;
+    task: (file: KubbFile.ResolvedFile) => Promise<KubbFile.ResolvedFile>;
 };
 type Events = {
     execute: [executer: Executer];
     executed: [executer: Executer];
-    error: [pluginError: PluginError];
+    error: [error: Error];
 };
 declare class PluginManager {
     #private;
-    plugins: KubbPlugin[];
+    readonly plugins: KubbPluginWithLifeCycle[];
     readonly fileManager: FileManager;
-    readonly eventEmitter: EventEmitter<Events>;
-    readonly queue: Queue;
-    readonly executed: Executer[];
+    readonly events: EventEmitter<Events>;
+    readonly config: KubbConfig;
+    readonly executed: Array<Executer>;
     readonly logger: Logger;
-    constructor(config: KubbConfig, options: Options$1);
-    resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath;
+    readonly queue: PQueue;
+    constructor(config: KubbConfig, options: Options$2);
+    resolvePath: <TOptions = object>(params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
+    /**
+     * Instead of calling `pluginManager.events.on` you can use `pluginManager.on`. This one also has better types.
+     */
     on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void;
     /**
-     * Run only hook for a specific plugin name
+     * Run a specific hookName for plugin x.
      */
     hookForPlugin<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
         pluginKey: KubbPlugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
     }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null;
+    /**
+     * Run a specific hookName for plugin x.
+     */
     hookForPluginSync<H extends PluginLifecycleHooks>({ pluginKey, hookName, parameters, }: {
         pluginKey: KubbPlugin['key'];
         hookName: H;
         parameters: PluginParameter<H>;
     }): Array<ReturnType<ParseResult<H>>> | null;
     /**
-     * Chains, first non-null result stops and returns
+     * First non-null result stops and will return it's value.
      */
     hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
         hookName: H;
@@ -273,7 +95,7 @@ declare class PluginManager {
         skipped?: ReadonlySet<KubbPlugin> | null;
     }): Promise<SafeParseResult<H>>;
     /**
-     * Chains, first non-null result stops and returns
+     * First non-null result stops and will return it's value.
      */
     hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
         hookName: H;
@@ -281,14 +103,14 @@ declare class PluginManager {
         skipped?: ReadonlySet<KubbPlugin> | null;
     }): SafeParseResult<H>;
     /**
-     * Parallel, runs all plugins
+     * Run all plugins in parallel(order will be based on `this.plugin` and if `pre` or `post` is set).
      */
     hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
         hookName: H;
         parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
     }): Promise<Awaited<TOuput>[]>;
     /**
-     * Chains, reduces returned value, handling the reduced value as the first hook argument
+     * Chain all plugins, `reduce` can be passed through to handle every returned value. The return value of the first plugin will be used as the first parameter for the plugin after that.
      */
     hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
         hookName: H;
@@ -304,7 +126,7 @@ declare class PluginManager {
     }): 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"];
+    static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
 }
 
 interface Cache<TStore extends object = object> {
@@ -334,7 +156,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<Omit<UnknownKubbUserPlugin, 'api'> | KubbUnionPlugins | [name: string, options: object]>;
 };
 type InputPath = {
     /**
@@ -419,44 +241,76 @@ type CLIOptions = {
      */
     logLevel?: LogLevel;
 };
-type BuildOutput = {
-    files: FileManager['files'];
-    pluginManager: PluginManager;
-};
-type KubbPluginKind = 'schema' | 'controller';
 type KubbUnionPlugins = PluginUnion;
 type KubbObjectPlugin = keyof OptionsPlugins;
+type PluginFactoryOptions<
+/**
+ * Name to be used for the plugin, this will also be used for they key.
+ */
+TName extends string = string, 
+/**
+ * Options of the plugin.
+ */
+TOptions extends object = object, 
+/**
+ * Options of the plugin that can be used later on, see `options` inside your plugin config.
+ */
+TResolvedOptions extends object = TOptions, 
+/**
+ * API that you want to expose to other plugins.
+ */
+TAPI = any, 
+/**
+ * When calling `resolvePath` you can specify better types.
+ */
+TResolvePathOptions extends object = object, 
+/**
+ * When using @kubb/react(based on React) you can specify here which types should be used when calling render.
+ * Always extend from `AppMeta` of the core.
+ */
+TAppMeta = unknown> = {
+    name: TName;
+    /**
+     * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
+     */
+    key: [name: TName | string, identifier?: string | number];
+    options: TOptions;
+    resolvedOptions: TResolvedOptions;
+    api: TAPI;
+    resolvePathOptions: TResolvePathOptions;
+    appMeta: {
+        pluginManager: PluginManager;
+        plugin: KubbPlugin<PluginFactoryOptions<TName, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>;
+    } & TAppMeta;
+};
 type GetPluginFactoryOptions<TPlugin extends KubbUserPlugin> = TPlugin extends KubbUserPlugin<infer X> ? X : never;
 type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
+     * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
      * @example @kubb/typescript
      */
     name: TOptions['name'];
     /**
-     * Internal key used when a developer uses more than one of the same plugin
-     * @private
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
-    key?: TOptions['key'];
+    options: TOptions['resolvedOptions'];
     /**
-     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
      */
-    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;
-} : {
+    pre?: Array<string>;
     /**
-     * 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
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
      */
-    kind: TOptions['kind'];
+    post?: Array<string>;
+} & (TOptions['api'] extends never ? {
+    api?: never;
+} : {
+    api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api'];
 });
+type KubbUserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbUserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any>>;
 type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
@@ -469,83 +323,69 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
      */
     key: TOptions['key'];
     /**
-     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
      */
-    options: TOptions['options'] extends never ? undefined : TOptions['options'];
+    pre?: Array<string>;
     /**
-     * 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
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
      */
-    kind?: KubbPluginKind;
-} & PluginLifecycle<TOptions> & (TOptions['api'] extends never ? {
+    post?: Array<string>;
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    options: TOptions['resolvedOptions'];
+} & (TOptions['api'] extends never ? {
     api?: never;
 } : {
     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>> = {
-    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;
-    resolvePathOptions: resolvePathOptions;
-};
+type KubbPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbPlugin<TOptions> & PluginLifecycle<TOptions>;
 type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-    /**
-     * 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<true>;
     /**
      * Start of the lifecycle of a plugin.
      * @type hookParallel
      */
-    buildStart?: (this: PluginContext, kubbConfig: KubbConfig) => PossiblePromise<void>;
+    buildStart?: (this: PluginContext<TOptions>, kubbConfig: KubbConfig) => PossiblePromise<void>;
     /**
      * Resolve to a Path based on a baseName(example: `./Pet.ts`) and directory(example: `./models`).
      * Options can als be included.
      * @type hookFirst
      * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
      */
-    resolvePath?: (this: PluginContext, baseName: string, directory?: string, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath;
+    resolvePath?: (this: PluginContext<TOptions>, baseName: string, directory?: string, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath;
     /**
      * Resolve to a name based on a string.
      * Useful when converting to PascalCase or camelCase.
      * @type hookFirst
      * @example ('pet') => 'Pet'
      */
-    resolveName?: (this: PluginContext, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    resolveName?: (this: PluginContext<TOptions>, name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
     /**
      * 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<TransformResult | null>;
+    load?: (this: Omit<PluginContext<TOptions>, 'addFile'>, path: KubbFile.Path) => PossiblePromise<TransformResult | null>;
     /**
      * Transform the source-code.
      * @type hookReduceArg0
      */
-    transform?: (this: Omit<PluginContext, 'addFile'>, source: string, path: KubbFile.Path) => PossiblePromise<TransformResult>;
+    transform?: (this: Omit<PluginContext<TOptions>, '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<string | void>;
+    writeFile?: (this: Omit<PluginContext<TOptions>, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise<string | void>;
     /**
      * End of the plugin lifecycle.
      * @type hookParallel
      */
-    buildEnd?: (this: PluginContext) => PossiblePromise<void>;
+    buildEnd?: (this: PluginContext<TOptions>) => 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>> = {
+type ResolvePathParams<TOptions = object> = {
     pluginKey?: KubbPlugin['key'];
     baseName: string;
     directory?: string | undefined;
@@ -557,15 +397,20 @@ type ResolvePathParams<TOptions = Record<string, unknown>> = {
 type ResolveNameParams = {
     name: string;
     pluginKey?: KubbPlugin['key'];
-    type?: 'file' | 'function';
+    /**
+     * `file` will be used to customize the name of the created file(use of camelCase)
+     * `function` can be used used to customize the exported functions(use of camelCase)
+     * `type` is a special type for TypeScript(use of PascalCase)
+     */
+    type?: 'file' | 'function' | 'type';
 };
-type PluginContext<TOptions = Record<string, unknown>> = {
+type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     config: KubbConfig;
     cache: Cache<PluginCache>;
     fileManager: FileManager;
     pluginManager: PluginManager;
     addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.File>>;
-    resolvePath: (params: ResolvePathParams<TOptions>) => KubbFile.OptionalPath;
+    resolvePath: (params: ResolvePathParams<TOptions['resolvePathOptions']>) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     logger: Logger;
     /**
@@ -575,44 +420,170 @@ type PluginContext<TOptions = Record<string, unknown>> = {
     /**
      * Current plugin
      */
-    plugin: KubbPlugin;
+    plugin: KubbPlugin<TOptions>;
 };
 type TransformResult = string | null;
-type AppMeta = {
-    pluginManager: PluginManager;
+
+type BasePath<T extends string = string> = `${T}/`;
+declare namespace KubbFile {
+    type Import = {
+        /**
+         * Import name to be used
+         * @example ["useState"]
+         * @example "React"
+         */
+        name: string | Array<string | {
+            propertyName: string;
+            name?: string;
+        }>;
+        /**
+         * Path for the import
+         * @xample '@kubb/core'
+         */
+        path: string;
+        /**
+         * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
+         */
+        isTypeOnly?: boolean;
+        /**
+         * Add `* as` prefix to the import, this will result in: `import * as path from './path'`.
+         */
+        isNameSpace?: boolean;
+        /**
+         * When root is set it will get the path with relative getRelativePath(root, path).
+         */
+        root?: string;
+    };
+    type Export = {
+        /**
+         * Export name to be used.
+         * @example ["useState"]
+         * @example "React"
+         */
+        name?: string | Array<string>;
+        /**
+         * Path for the import.
+         * @xample '@kubb/core'
+         */
+        path: string;
+        /**
+         * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
+         */
+        isTypeOnly?: boolean;
+        /**
+         * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
+         */
+        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}`;
+    type Mode = 'file' | 'directory';
+    /**
+     * 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
+     */
+    type BaseName = `${string}${Extname}`;
+    /**
+     * Path will be full qualified path to a specified file
+     */
+    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;
+        /**
+         * Name to be used to create the path
+         * Based on UNIX basename, `${name}.extName`
+         * @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
+         * This will also ignore the combinefiles utils
+         * @default `false`
+         */
+        override?: boolean;
+        /**
+         * Use extra meta, this is getting used to generate the barrel/index files.
+         */
+        meta?: TMeta;
+        /**
+         * This will override `process.env[key]` inside the `source`, see `getFileSource`.
+         */
+        env?: NodeJS.ProcessEnv;
+    };
+    type ResolvedFile<TMeta extends FileMetaBase = FileMetaBase, TBaseName extends BaseName = BaseName> = KubbFile.File<TMeta, TBaseName> & {
+        /**
+         * @default crypto.randomUUID()
+         */
+        id: UUID;
+        /**
+         * Contains the first part of the baseName, generated based on baseName
+         * @link  https://nodejs.org/api/path.html#pathformatpathobject
+         */
+        name: string;
+    };
+}
+type AddResult<T extends Array<KubbFile.File>> = Promise<Awaited<GreaterThan<T['length'], 1> extends true ? Promise<KubbFile.ResolvedFile[]> : Promise<KubbFile.ResolvedFile>>>;
+type AddIndexesProps = {
+    /**
+     * Root based on root and output.path specified in the config
+     */
+    root: string;
+    /**
+     * Output for plugin
+     */
+    output: {
+        path: string;
+        exportAs?: string;
+        extName?: KubbFile.Extname;
+        exportType?: 'barrel' | false;
+    };
+    options?: BarrelManagerOptions;
+    meta?: KubbFile.File['meta'];
 };
-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 Options$1 = {
+    queue?: PQueue;
+    task?: (file: KubbFile.ResolvedFile) => Promise<KubbFile.ResolvedFile>;
+};
+declare class FileManager {
+    #private;
+    constructor({ task, queue }?: Options$1);
+    get files(): Array<KubbFile.File>;
+    get isExecuting(): boolean;
+    add<T extends Array<KubbFile.File> = Array<KubbFile.File>>(...files: T): AddResult<T>;
+    addIndexes({ root, output, 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;
+}
 
 type BuildOptions = {
     config: PluginContext['config'];
@@ -621,7 +592,16 @@ type BuildOptions = {
      */
     logger?: Logger;
 };
+type BuildOutput = {
+    files: FileManager['files'];
+    pluginManager: PluginManager;
+    /**
+     * Only for safeBuild
+     */
+    error?: Error;
+};
 declare function build(options: BuildOptions): Promise<BuildOutput>;
+declare function safeBuild(options: BuildOptions): Promise<BuildOutput>;
 
 /**
  * Type helper to make it easier to use kubb.config.js
@@ -633,6 +613,15 @@ declare function defineConfig(options: PossiblePromise<KubbUserConfig | Array<Ku
 cliOptions: CLIOptions) => PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>)): typeof options;
 declare function isInputPath(result: KubbConfig | undefined): result is KubbConfig<InputPath>;
 
+/**
+ * Behaves as an Error to log a warning in the console(still stops the execution)
+ */
+declare class Warning extends Error {
+    constructor(message?: string, options?: {
+        cause: Error;
+    });
+}
+
 /**
  * Abstract class that contains the building blocks for plugins to create their own Generator
  * @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
@@ -663,22 +652,23 @@ declare class PackageManager {
     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;
+    getVersion(dependency: DependencyName | RegExp): Promise<DependencyVersion | undefined>;
+    getVersionSync(dependency: DependencyName | RegExp): DependencyVersion | undefined;
+    isValid(dependency: DependencyName | RegExp, version: DependencyVersion): Promise<boolean>;
+    isValidSync(dependency: DependencyName | RegExp, version: DependencyVersion): boolean;
 }
 
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPlugin<T>;
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPluginWithLifeCycle<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 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 HookParallelOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>;
+type Strategy = 'seq' | 'first' | 'parallel';
+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> : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue> : never;
 
 type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;
 type Options<TState = any> = {
@@ -690,13 +680,6 @@ declare class PromiseManager<TState = any> {
     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
- */
-declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput> extends Generator<TOptions> {
-    abstract build(schema: TInput, name: string, description?: string): TOutput;
-}
-
 interface _Register {
 }
 type Plugins = _Register;
@@ -707,4 +690,4 @@ type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options'];
 type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>;
 type Plugin = keyof Plugins;
 
-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 };
+export { type CLIOptions, FileManager, Generator, type GetPluginFactoryOptions, type InputData, type InputPath, type KubbConfig, KubbFile, type KubbObjectPlugin, type KubbPlugin, type KubbPluginWithLifeCycle, type KubbUnionPlugins, type KubbUserConfig, type KubbUserPlugin, type KubbUserPluginWithLifeCycle, type OptionsOfPlugin, type OptionsPlugins, PackageManager, type Plugin, type PluginCache, type PluginContext, type PluginFactoryOptions, type PluginLifecycle, type PluginLifecycleHooks, PluginManager, type PluginParameter, type PluginUnion, type Plugins, PromiseManager, type ResolveNameParams, type ResolvePathParams, type TransformResult, Warning, type _Register, build, createPlugin, build as default, defineConfig, isInputPath, pluginName as name, pluginName, safeBuild };