@kubb/core 0.0.0-canary-20231213204140

package/dist/index.d.cts

@@ -0,0 +1,693 @@
+import PQueue from 'p-queue';
+import { w as write, r as read } from './write-A6VgHkYA.cjs';
+import { PossiblePromise, GreaterThan, TupleToUnion, ObjValueTuple } from '@kubb/types';
+import { DirectoryTreeOptions } from 'directory-tree';
+import { Logger, LogLevel } from './logger.cjs';
+import 'ora';
+
+type BarrelManagerOptions = {
+    treeNode?: DirectoryTreeOptions;
+    isTypeOnly?: boolean;
+    /**
+     * Add .ts or .js
+     */
+    extName?: KubbFile.Extname;
+};
+
+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>;
+/**
+ * Get the type of the first argument in a function.
+ * @example Arg0<(a: string, b: number) => void> -> string
+ */
+type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
+type Strategy$1 = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
+type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    strategy: Strategy$1;
+    hookName: H;
+    plugin: KubbPlugin;
+    parameters?: unknown[] | undefined;
+    output?: unknown;
+};
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
+type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
+    result: Result;
+    plugin: KubbPlugin;
+};
+type Options$2 = {
+    logger: Logger;
+    /**
+     * Task for the FileManager
+     */
+    task: (file: KubbFile.ResolvedFile) => Promise<KubbFile.ResolvedFile>;
+};
+type Events = {
+    execute: [executer: Executer];
+    executed: [executer: Executer];
+    error: [error: Error];
+};
+declare class PluginManager {
+    #private;
+    readonly plugins: KubbPluginWithLifeCycle[];
+    readonly fileManager: FileManager;
+    readonly events: EventEmitter<Events>;
+    readonly config: KubbConfig;
+    readonly executed: Array<Executer>;
+    readonly logger: Logger;
+    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 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;
+    /**
+     * First non-null result stops and will return it's value.
+     */
+    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: PluginParameter<H>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): Promise<SafeParseResult<H>>;
+    /**
+     * First non-null result stops and will return it's value.
+     */
+    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: PluginParameter<H>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): SafeParseResult<H>;
+    /**
+     * 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>[]>;
+    /**
+     * 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;
+        parameters: PluginParameter<H>;
+        reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => PossiblePromise<Argument0<H> | null>;
+    }): Promise<Argument0<H>>;
+    /**
+     * Chains plugins
+     */
+    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
+        hookName: H;
+        parameters?: PluginParameter<H>;
+    }): Promise<void>;
+    getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: KubbPlugin['key']): KubbPlugin[];
+    static getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = T3 extends never ? T2 extends never ? [T1: KubbPlugin<T1>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>, T3: KubbPlugin<T3>]>(plugins: Array<KubbPlugin>, dependedPluginNames: string | string[]): TOutput;
+    static get hooks(): readonly ["buildStart", "resolvePath", "resolveName", "load", "transform", "writeFile", "buildEnd"];
+}
+
+interface Cache<TStore extends object = object> {
+    delete(id: keyof TStore): boolean;
+    get(id: keyof TStore): TStore[keyof TStore] | null;
+    has(id: keyof TStore): boolean;
+    set(id: keyof TStore, value: unknown): void;
+}
+
+/**
+ * Config used in `kubb.config.js`
+ *
+ * @example import { defineConfig } from '@kubb/core'
+ * export default defineConfig({
+ * ...
+ * })
+ */
+type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
+    /**
+     * 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;
+    /**
+     * Plugin type can be KubbJSONPlugin or KubbPlugin
+     * Example: ['@kubb/swagger', { output: false }]
+     * Or: createSwagger({ output: false })
+     */
+    plugins?: Array<Omit<UnknownKubbUserPlugin, 'api'> | KubbUnionPlugins | [name: string, options: object]>;
+};
+type InputPath = {
+    /**
+     * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
+     */
+    path: string;
+};
+type InputData = {
+    /**
+     * `string` or `object` containing the data.
+     */
+    data: string | unknown;
+};
+type Input = InputPath | InputData;
+/**
+ * @private
+ */
+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: TInput;
+    output: {
+        /**
+         * Path to be used to export all generated files.
+         * This can be an absolute path, or a path relative based of the defined `root` option.
+         */
+        path: string;
+        /**
+         * Clean output directory before each build.
+         */
+        clean?: boolean;
+        /**
+         * Write files to the fileSystem
+         * This is being used for the playground.
+         * @default true
+         */
+        write?: boolean;
+    };
+    /**
+     * Array of Kubb plugins to use.
+     * The plugin/package can forsee some options that you need to pass through.
+     * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
+     */
+    plugins?: Array<KubbPlugin>;
+    /**
+     * Hooks that will be called when a specific action is triggered in Kubb.
+     */
+    hooks?: {
+        /**
+         * Hook that will be triggered at the end of all executions.
+         * Useful for running Prettier or ESLint to format/lint your code.
+         */
+        done?: string | Array<string>;
+    };
+};
+type CLIOptions = {
+    /**
+     * Path to `kubb.config.js`
+     */
+    config?: string;
+    /**
+     * Watch changes on input
+     */
+    watch?: string;
+    /**
+     * Log level to report when using the CLI
+     *
+     * `silent` will hide all information that is not relevant
+     *
+     * `info` will show all information possible(not related to the PluginManager)
+     *
+     * `debug` will show all information possible(related to the PluginManager), handy for seeing logs
+     * @default `silent`
+     */
+    logLevel?: LogLevel;
+};
+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'];
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    options: TOptions['resolvedOptions'];
+    /**
+     * 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.
+     */
+    pre?: Array<string>;
+    /**
+     * 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.
+     */
+    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
+     * @example @kubb/typescript
+     */
+    name: TOptions['name'];
+    /**
+     * Internal key used when a developer uses more than one of the same plugin
+     * @private
+     */
+    key: TOptions['key'];
+    /**
+     * 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.
+     */
+    pre?: Array<string>;
+    /**
+     * 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.
+     */
+    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 KubbPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbPlugin<TOptions> & PluginLifecycle<TOptions>;
+type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
+    /**
+     * Start of the lifecycle of a plugin.
+     * @type hookParallel
+     */
+    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<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<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<TOptions>, 'addFile'>, path: KubbFile.Path) => PossiblePromise<TransformResult | null>;
+    /**
+     * Transform the source-code.
+     * @type hookReduceArg0
+     */
+    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<TOptions>, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise<string | void>;
+    /**
+     * End of the plugin lifecycle.
+     * @type hookParallel
+     */
+    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 = object> = {
+    pluginKey?: KubbPlugin['key'];
+    baseName: string;
+    directory?: string | undefined;
+    /**
+     * Options to be passed to 'resolvePath' 3th parameter
+     */
+    options?: TOptions;
+};
+type ResolveNameParams = {
+    name: string;
+    pluginKey?: KubbPlugin['key'];
+    /**
+     * `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 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['resolvePathOptions']>) => KubbFile.OptionalPath;
+    resolveName: (params: ResolveNameParams) => string;
+    logger: Logger;
+    /**
+     * All plugins
+     */
+    plugins: KubbPlugin[];
+    /**
+     * Current plugin
+     */
+    plugin: KubbPlugin<TOptions>;
+};
+type TransformResult = string | null;
+
+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 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'];
+    /**
+     * @default Logger without the spinner
+     */
+    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
+ * 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 | Array<KubbUserConfig>> | ((
+/** The options derived from the CLI flags */
+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
+ */
+declare abstract class Generator<TOptions = unknown, TContext = unknown> {
+    #private;
+    constructor(options?: TOptions, context?: TContext);
+    get options(): TOptions;
+    get context(): TContext;
+    set options(options: TOptions);
+    abstract build(...params: unknown[]): unknown;
+}
+
+type PackageJSON = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};
+type DependencyName = string;
+type DependencyVersion = string;
+declare class PackageManager {
+    #private;
+    constructor(workspace?: string);
+    set workspace(workspace: string);
+    get workspace(): string | undefined;
+    normalizeDirectory(directory: string): string;
+    getLocation(path: string): string;
+    import(path: string): Promise<any | undefined>;
+    getPackageJSON(): Promise<PackageJSON | undefined>;
+    getPackageJSONSync(): PackageJSON | undefined;
+    static setVersion(dependency: DependencyName, version: DependencyVersion): void;
+    getVersion(dependency: DependencyName | 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']) => 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 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 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> = {
+    nullCheck?: (state: TState) => boolean;
+};
+declare class PromiseManager<TState = any> {
+    #private;
+    constructor(options?: Options<TState>);
+    run<TInput extends Array<PromiseFunc<TValue, null>>, TValue, TStrategy extends Strategy, TOutput = StrategySwitch<TStrategy, TInput, TValue>>(strategy: TStrategy, promises: TInput): TOutput;
+}
+
+interface _Register {
+}
+type Plugins = _Register;
+type OptionsPlugins = {
+    [K in keyof Plugins]: Plugins[K]['options'];
+};
+type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options'];
+type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>;
+type Plugin = keyof Plugins;
+
+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 };