@kubb/core 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/index.d.cts

@@ -1,3 +1,4 @@
+import { PossiblePromise, GreaterThan, TupleToUnion, ObjValueTuple } from '@kubb/types';
 import { DirectoryTreeOptions } from 'directory-tree';
 import { Ora } from 'ora';
 
@@ -45,145 +46,6 @@ declare class Queue {
     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";
@@ -223,7 +85,7 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
     result: Result;
     plugin: KubbPlugin;
 };
-type Options$1 = {
+type Options$2 = {
     logger: Logger;
     /**
      * Task for the FileManager
@@ -237,17 +99,18 @@ type Options$1 = {
 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 config: KubbConfig;
     readonly executed: Executer[];
     readonly logger: Logger;
-    constructor(config: KubbConfig, options: Options$1);
+    constructor(config: KubbConfig, options: Options$2);
     resolvePath: (params: ResolvePathParams) => KubbFile.OptionalPath;
     resolveName: (params: ResolveNameParams) => string;
     on<TEventName extends keyof Events & string>(eventName: TEventName, handler: (...eventArg: Events[TEventName]) => void): void;
@@ -334,7 +197,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,13 +282,54 @@ 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, 
+/**
+ * @type "schema" | "controller"
+ */
+TKind extends KubbPluginKind = KubbPluginKind, 
+/**
+ * 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;
+    kind: TKind;
+    /**
+     * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
+     */
+    key: [kind: TKind | undefined, name: TName | string, identifier?: string | number];
+    options: TOptions;
+    resolvedOptions: TResolvedOptions;
+    api: TAPI;
+    resolvePathOptions: TResolvePathOptions;
+    appMeta: {
+        pluginManager: PluginManager;
+        plugin: KubbPlugin<PluginFactoryOptions<TName, TKind, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>;
+    } & TAppMeta;
+};
 type GetPluginFactoryOptions<TPlugin extends KubbUserPlugin> = TPlugin extends KubbUserPlugin<infer X> ? X : never;
 type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
@@ -441,11 +345,11 @@ type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions
     /**
      * 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 ? {
+    options: TOptions['resolvedOptions'];
+} & (TOptions['api'] extends never ? {
     api?: never;
 } : {
-    api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext, 'addFile'>) => TOptions['api'];
+    api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api'];
 }) & (TOptions['kind'] extends never ? {
     kind?: never;
 } : {
@@ -457,6 +361,8 @@ type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions
      */
     kind: TOptions['kind'];
 });
+type KubbUserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbUserPlugin<TOptions> & PluginLifecycle<TOptions>;
+type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any, any>>;
 type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
     /**
      * Unique name used for the plugin
@@ -471,81 +377,70 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
-    options: TOptions['options'] extends never ? undefined : TOptions['options'];
+    options: TOptions['resolvedOptions'];
     /**
      * 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;
-} & PluginLifecycle<TOptions> & (TOptions['api'] extends never ? {
+    kind?: TOptions['kind'];
+} & (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>;
+    validate?: (this: Omit<PluginContext<TOptions>, '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 +452,15 @@ type ResolvePathParams<TOptions = Record<string, unknown>> = {
 type ResolveNameParams = {
     name: string;
     pluginKey?: KubbPlugin['key'];
-    type?: 'file' | 'function';
+    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 +470,112 @@ 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 = {
+        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 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?: Queue;
+    task?: QueueJob<KubbFile.ResolvedFile>;
+    /**
+     * Timeout between writes
+     */
+    timeout?: number;
+};
+declare class FileManager {
+    #private;
+    constructor(options?: 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, 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>;
 
 type BuildOptions = {
     config: PluginContext['config'];
@@ -621,7 +584,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 +605,17 @@ 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;
+    });
+}
+declare class ValidationPluginError extends 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
@@ -669,7 +652,7 @@ declare class PackageManager {
     isValidSync(dependency: DependencyName, 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";
 
@@ -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 { CLIOptions, FileManager, Generator, GetPluginFactoryOptions, InputData, InputPath, KubbConfig, KubbFile, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbPluginWithLifeCycle, KubbUnionPlugins, KubbUserConfig, KubbUserPlugin, KubbUserPluginWithLifeCycle, OptionsOfPlugin, OptionsPlugins, PackageManager, Plugin, PluginCache, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, PluginParameter, PluginUnion, Plugins, PromiseManager, ResolveNameParams, ResolvePathParams, SchemaGenerator, TransformResult, ValidationPluginError, Warning, _Register, build, combineExports, combineImports, createPlugin, build as default, defineConfig, isInputPath, pluginName as name, pluginName, safeBuild };