@kubb/core 1.14.0 → 1.14.2

package/dist/index.d.ts

@@ -1,22 +1,99 @@
-import { Ora } from 'ora';
 import { DirectoryTreeOptions } from 'directory-tree';
+import { Ora } from 'ora';
 export { default as pc } from 'picocolors';
 
+interface Cache<TStore extends object = object> {
+    delete(id: keyof TStore): boolean;
+    get(id: keyof TStore): TStore[keyof TStore] | null;
+    has(id: keyof TStore): boolean;
+    set(id: keyof TStore, value: unknown): void;
+}
+declare function createPluginCache<TStore extends PluginCache>(Store?: TStore): Cache<TStore>;
+
+declare function clean(path: string): Promise<void>;
+
+type FunctionParamsASTWithoutType = {
+    name?: string;
+    type?: string;
+    /**
+     * @default true
+     */
+    required?: boolean;
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    default?: string;
+};
+type FunctionParamsASTWithType = {
+    name?: never;
+    type: string;
+    /**
+     * @default true
+     */
+    required?: boolean;
+    /**
+     * @default true
+     */
+    enabled?: boolean;
+    default?: string;
+};
+type FunctionParamsAST = FunctionParamsASTWithoutType | FunctionParamsASTWithType;
+declare class FunctionParams {
+    type?: 'generics' | 'typed';
+    items: FunctionParamsAST[];
+    constructor(type?: 'generics' | 'typed');
+    add(item: FunctionParamsAST | Array<FunctionParamsAST | undefined> | undefined): FunctionParams;
+    toString(): string;
+}
+
+declare function 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'> & {
     reason: T;
 };
 
-declare function write(data: string, path: string): Promise<void>;
+declare function createJSDocBlockText({ comments }: {
+    comments: Array<string>;
+}): string;
 
-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;
+type LogType = 'error' | 'info' | 'warning';
+type Logger = {
+    log: (message: string | null) => void;
+    error: (message: string | null) => void;
+    info: (message: string | null) => void;
+    warn: (message: string | null) => void;
+    spinner?: Ora;
+    logs: string[];
+};
+declare function createLogger(spinner?: Ora): Logger;
+
+declare function nameSorter<T extends {
+    name: string;
+}>(a: T, b: T): 0 | 1 | -1;
+
+type QueueJob<T = unknown> = {
+    (...args: unknown[]): Promise<T> | Promise<void>;
+};
+type RunOptions = {
+    controller?: AbortController;
+    name?: string;
+    description?: string;
+};
+declare class Queue {
+    #private;
+    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;
 }
-declare function createPluginCache<TStore extends PluginCache>(Store?: TStore): Cache<TStore>;
+
+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 & {
@@ -36,7 +113,7 @@ declare namespace KubbFile {
     };
     type UUID = string;
     type Source = string;
-    type Extname = '.ts' | '.js' | '.tsx' | `.${string}`;
+    type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
     type Mode = 'file' | 'directory';
     type BaseName = `${string}${Extname}`;
     type Path = string;
@@ -84,34 +161,21 @@ declare function getPathMode(path: string | undefined | null): KubbFile.Mode;
 declare function read(path: string): Promise<string>;
 declare function readSync(path: string): string;
 
-declare function nameSorter<T extends {
-    name: string;
-}>(a: T, b: T): 0 | 1 | -1;
+declare function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data?: TData | undefined): string;
 
-declare function createJSDocBlockText({ comments }: {
-    comments: Array<string>;
-}): string;
+declare class SummaryError extends Error {
+    summary: string[];
+    constructor(message: string, options: {
+        cause: Error;
+        summary?: string[];
+    });
+}
 
-declare function getUniqueName(originalName: string, data: Record<string, number>): string;
+declare const throttle: <R, A extends any[]>(fn: (...args: A) => R, delay: number) => [(...args: A) => R | undefined, () => void];
 
 declare function timeout(ms: number): Promise<unknown>;
 
-type QueueJob<T = unknown> = {
-    (...args: unknown[]): Promise<T> | Promise<void>;
-};
-type RunOptions = {
-    controller?: AbortController;
-    name?: string;
-    description?: string;
-};
-declare class Queue {
-    #private;
-    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;
-}
+declare function combineCodes(codes: string[]): string;
 
 declare function escape(text?: string): string;
 /**
@@ -123,12 +187,6 @@ declare function jsStringEscape(input: any): string;
 
 declare function transformReservedWord(word: string): string;
 
-declare function combineCodes(codes: string[]): string;
-
-declare function renderTemplate<TData extends Record<string, unknown> = Record<string, unknown>>(template: string, data?: TData | undefined): string;
-
-declare function clean(path: string): Promise<void>;
-
 type TreeNodeOptions = DirectoryTreeOptions;
 declare class TreeNode<T = unknown> {
     data: T;
@@ -145,54 +203,6 @@ declare class TreeNode<T = unknown> {
 
 declare const uniqueIdFactory: (counter: number) => (str?: string) => string;
 
-/**
- * Normalizes directories to have a trailing slash.
- * Resolve is pretty finicky -- if the directory name doesn't have
- * a trailing slash then it tries to look in the parent directory.
- * i.e., if the directory is "/usr/nzakas/foo" it will start the
- * search in /usr/nzakas. However, if the directory is "/user/nzakas/foo/",
- * then it will start the search in /user/nzakas/foo.
- * @param {string} directory The directory to check.
- * @returns {string} The normalized directory.
- */
-declare function normalizeDirectory(directory: string): string;
-declare function getLocation(path: string, cwd?: string): string;
-declare function importModule(path: string, cwd?: string): Promise<any | undefined>;
-
-declare const throttle: <R, A extends any[]>(fn: (...args: A) => R, delay: number) => [(...args: A) => R | undefined, () => void];
-
-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;
-    });
-}
-
-type LogType = 'error' | 'info' | 'warning';
-type Logger = {
-    log: (message: string | null) => void;
-    error: (message: string | null) => void;
-    info: (message: string | null) => void;
-    warn: (message: string | null) => void;
-    spinner?: Ora;
-    logs: string[];
-};
-declare function createLogger(spinner?: Ora): Logger;
-
-declare 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 URLObject = {
     url: string;
     params?: Record<string, string>;
@@ -210,7 +220,7 @@ declare class URLPath {
      * @example /pet/{petId} => /pet/:petId
      */
     get URL(): string;
-    get isUrl(): boolean;
+    get isURL(): boolean;
     /**
      * Convert Swagger path to template literals/ template strings(camelcase)
      * @example /pet/{petId} => `/pet/${petId}`
@@ -220,7 +230,7 @@ declare class URLPath {
     get template(): string;
     get object(): URLObject | string;
     get params(): Record<string, string> | undefined;
-    toObject(options?: ObjectOptions): URLObject | string;
+    toObject({ type, replacer, stringify }?: ObjectOptions): URLObject | string;
     /**
      * Convert Swagger path to template literals/ template strings(camelcase)
      * @example /pet/{petId} => `/pet/${petId}`
@@ -228,58 +238,25 @@ declare class URLPath {
      * @example /account/userID => `/account/${userId}`
      */
     toTemplateString(replacer?: (pathParam: string) => string): string;
-    /**
-     * Convert Swagger path to template literals/ template strings(camelcase)
-     * @example /pet/{petId} => `/pet/${petId}`
-     * @example /account/monetary-accountID => `/account/${monetaryAccountId}`
-     * @example /account/userID => `/account/${userId}`
-     */
-    static toTemplateString(path: string, replacer?: (pathParam: string) => string): string;
     getParams(replacer?: (pathParam: string) => string): Record<string, string> | undefined;
-    static getParams(path: string, replacer?: (pathParam: string) => string): Record<string, string> | undefined;
     /**
      * Convert Swagger path to URLPath(syntax of Express)
      * @example /pet/{petId} => /pet/:petId
      */
     toURLPath(): string;
-    static toURLPath(path: string): string;
-    static toObject(path: string, { type, replacer, stringify }?: ObjectOptions): URLObject | string;
-    static isURL(path: string): boolean;
 }
 
-type FunctionParamsAST = {
-    name?: string;
-    type?: string;
-    /**
-     * @default true
-     */
-    required?: boolean;
-    /**
-     * @default true
-     */
-    enabled?: boolean;
-    default?: string;
-} | {
-    name?: never;
-    type: string;
-    /**
-     * @default true
-     */
-    required?: boolean;
-    /**
-     * @default true
-     */
-    enabled?: boolean;
-    default?: string;
-};
-declare class FunctionParams {
-    type?: 'generics' | 'typed';
-    items: FunctionParamsAST[];
-    constructor(type?: 'generics' | 'typed');
-    add(item: FunctionParamsAST | Array<FunctionParamsAST | undefined> | undefined): FunctionParams;
-    toString(): 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 function write(data: string, path: string): Promise<void>;
+
 declare class FileManager {
     #private;
     constructor(options?: {
@@ -291,6 +268,7 @@ declare class FileManager {
     get isExecuting(): boolean;
     add(file: KubbFile.File): Promise<KubbFile.ResolvedFile>;
     addOrAppend(file: KubbFile.File): Promise<KubbFile.ResolvedFile>;
+    addIndexes(root: KubbFile.Path, extName?: KubbFile.Extname, options?: TreeNodeOptions): Promise<Array<KubbFile.File> | undefined>;
     getCacheByUUID(UUID: KubbFile.UUID): KubbFile.File | undefined;
     get(path: KubbFile.Path): Array<KubbFile.File> | undefined;
     remove(path: KubbFile.Path): void;
@@ -298,7 +276,7 @@ declare class FileManager {
     read(...params: Parameters<typeof read>): Promise<string>;
 }
 
-declare function getIndexes(root: string, options?: TreeNodeOptions): Array<KubbFile.File> | null;
+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)
@@ -309,6 +287,26 @@ declare function combineExports(exports: Array<KubbFile.Export>): Array<KubbFile
 declare function combineImports(imports: Array<KubbFile.Import>, exports: Array<KubbFile.Export>, source: string): Array<KubbFile.Import>;
 declare function createFileSource(file: KubbFile.File): string;
 
+type PackageJSON = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+};
+declare 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();
@@ -318,20 +316,12 @@ declare class EventEmitter<TEvents extends Record<string, any>> {
     removeAll(): void;
 }
 
-declare class PluginError extends Error {
-    pluginManager: PluginManager;
-    cause: Error;
-    constructor(message: string, options: {
-        cause: Error;
-        pluginManager: PluginManager;
-    });
-}
-
+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<PluginLifecycle[H]>[0];
+type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifecycle[H]>[0];
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
     strategy: Strategy;
@@ -340,13 +330,14 @@ type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
     parameters?: unknown[] | undefined;
     output?: unknown;
 };
-type ParseResult<H extends PluginLifecycleHooks> = PluginLifecycle[H];
+type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H];
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
     result: Result;
     plugin: KubbPlugin;
 };
+type PluginParameter<H extends PluginLifecycleHooks> = Parameters<RequiredPluginLifecycle[H]>;
 
-declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<string, unknown, false, any, Record<string, unknown>>>];
+declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<string, unknown, false, unknown, Record<string, unknown>>>];
 type Options$1 = {
     debug?: boolean;
     task: QueueJob<KubbFile.ResolvedFile>;
@@ -370,52 +361,47 @@ declare class PluginManager {
     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;
         hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
+        parameters: PluginParameter<H>;
     }): Promise<ReturnType<ParseResult<H>> | null> | null;
     hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
         pluginName: string;
         hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
+        parameters: PluginParameter<H>;
     }): ReturnType<ParseResult<H>> | null;
     /**
-     *
      * Chains, first non-null result stops and returns
      */
     hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
         hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
+        parameters: PluginParameter<H>;
         skipped?: ReadonlySet<KubbPlugin> | null;
     }): Promise<SafeParseResult<H>>;
     /**
-     *
      * Chains, first non-null result stops and returns
      */
     hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
         hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
+        parameters: PluginParameter<H>;
         skipped?: ReadonlySet<KubbPlugin> | null;
     }): SafeParseResult<H>;
     /**
-     *
      * Parallel, runs all plugins
      */
     hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
         hookName: H;
-        parameters?: Parameters<PluginLifecycle[H]> | undefined;
+        parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined;
     }): Promise<Awaited<TOuput>[]>;
     /**
-     *
      * Chains, reduces returned value, handling the reduced value as the first hook argument
      */
     hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
         hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
+        parameters: PluginParameter<H>;
         reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: KubbPlugin) => PossiblePromise<Argument0<H> | null>;
     }): Promise<Argument0<H>>;
     /**
@@ -423,14 +409,19 @@ declare class PluginManager {
      */
     hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
         hookName: H;
-        parameters?: Parameters<PluginLifecycle[H]>;
+        parameters?: PluginParameter<H>;
     }): Promise<void>;
     getPlugin(hookName: keyof PluginLifecycle, pluginName: string): KubbPlugin;
 }
 
-declare class ValidationPluginError extends Error {
+declare class PluginError extends Error {
+    pluginManager: PluginManager;
+    cause: Error;
+    constructor(message: string, options: {
+        cause: Error;
+        pluginManager: PluginManager;
+    });
 }
-declare function getDependedPlugins<TPlugins extends KubbPlugin[]>(plugins: KubbPlugin[], dependedPluginNames: string | string[]): TPlugins;
 
 declare class ParallelPluginError extends Error {
     errors: PluginError[];
@@ -443,20 +434,9 @@ declare class ParallelPluginError extends Error {
     findError<T extends Error = Error>(searchError: T | undefined): T | undefined;
 }
 
-type PackageJSON = {
-    dependencies?: Record<string, string>;
-    devDependencies?: Record<string, string>;
-};
-declare class PackageManager {
-    #private;
-    constructor(workspace?: string);
-    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 ValidationPluginError extends Error {
 }
+declare function getDependedPlugins<T1 extends PluginFactoryOptions, T2 extends PluginFactoryOptions = never, T3 extends PluginFactoryOptions = never, TOutput = T3 extends never ? T2 extends never ? [T1: KubbPlugin<T1>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>] : [T1: KubbPlugin<T1>, T2: KubbPlugin<T2>, T3: KubbPlugin<T3>]>(plugins: Array<KubbPlugin>, dependedPluginNames: string | string[]): TOutput;
 
 /**
  * Config used in `kubb.config.js`
@@ -480,6 +460,19 @@ type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
      */
     plugins?: Array<KubbPlugin> | Array<KubbJSONPlugins> | KubbObjectPlugins;
 };
+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
  */
@@ -490,17 +483,7 @@ type KubbConfig = {
      * @default process.cwd()
      */
     root: string;
-    input: {
-        /**
-         * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
-         */
-        path: string;
-    } | {
-        /**
-         * `string` or `object` containing the data.
-         */
-        data: string | unknown;
-    };
+    input: Input;
     output: {
         /**
          * Path to be used to export all generated files.
@@ -575,7 +558,7 @@ type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
-    options?: TOptions['options'];
+    options: TOptions['options'] extends never ? undefined : TOptions['options'];
     /**
      * Kind/type for the plugin
      * Type 'schema' can be used for JSON schema's, TypeScript types, ...
@@ -583,21 +566,22 @@ type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions
      * @default undefined
      */
     kind?: KubbPluginKind;
-    /**
-     * Define an api that can be used by other plugins, see `PluginManager' where we convert from `KubbUserPlugin` to `KubbPlugin`(used when calling `createPlugin`).
-     */
-    api?: (this: Omit<PluginContext, 'addFile'>) => TOptions['api'];
-} & Partial<PluginLifecycle<TOptions>>;
+} & Partial<PluginLifecycle<TOptions>> & (TOptions['api'] extends never ? {
+    api?: never;
+} : {
+    api: (this: Omit<PluginContext, 'addFile'>) => TOptions['api'];
+});
 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];
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
-    options?: TOptions['options'];
+    options: TOptions['options'] extends never ? undefined : TOptions['options'];
     /**
      * Kind/type for the plugin
      * Type 'schema' can be used for JSON schema's, TypeScript types, ...
@@ -605,12 +589,12 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
      * @default undefined
      */
     kind?: KubbPluginKind;
-    /**
-     * Define an api that can be used by other plugins, see `PluginManager' where we convert from `KubbUserPlugin` to `KubbPlugin`(used when calling `createPlugin`).
-     */
-    api?: TOptions['api'];
-} & Partial<PluginLifecycle<TOptions>>;
-type PluginFactoryOptions<Name = string, Options = unknown, Nested extends boolean = false, API = any, resolvePathOptions = Record<string, unknown>> = {
+} & PluginLifecycle<TOptions> & (TOptions['api'] extends never ? {
+    api?: never;
+} : {
+    api: TOptions['api'];
+});
+type PluginFactoryOptions<Name = string, Options = unknown | never, Nested extends boolean = false, API = unknown | never, resolvePathOptions = Record<string, unknown>> = {
     name: Name;
     options: Options;
     nested: Nested;
@@ -622,46 +606,46 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      * Valdiate all plugins to see if their depended plugins are installed and configured.
      * @type hookParallel
      */
-    validate: (this: Omit<PluginContext, 'addFile'>, plugins: KubbPlugin[]) => PossiblePromise<true>;
+    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, 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, 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, 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, '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, '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<void>;
+    writeFile?: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: KubbFile.Path) => PossiblePromise<void>;
     /**
      * End of the plugin lifecycle.
      * @type hookParallel
      */
-    buildEnd: (this: PluginContext) => PossiblePromise<void>;
+    buildEnd?: (this: PluginContext) => PossiblePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type PluginCache = Record<string, [number, unknown]>;
@@ -732,20 +716,6 @@ declare function defineConfig(options: PossiblePromise<KubbUserConfig> | ((
 /** The options derived from the CLI flags */
 cliOptions: CLIOptions) => PossiblePromise<KubbUserConfig>)): typeof options;
 
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbUserPlugin<T>> : KubbUserPlugin<T>;
-declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => ReturnType<KubbPluginFactory<T>>;
-type Options = {
-    config: PluginContext['config'];
-    fileManager: FileManager;
-    pluginManager: PluginManager;
-    resolvePath: PluginContext['resolvePath'];
-    resolveName: PluginContext['resolveName'];
-    logger: PluginContext['logger'];
-    getPlugins: () => KubbPlugin[];
-};
-type CorePluginOptions = PluginFactoryOptions<'core', Options, false, PluginContext>;
-declare const pluginName: CorePluginOptions['name'];
-
 /**
  * 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
@@ -766,4 +736,19 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-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, PossiblePromise, Prettify, Queue, QueueJob, 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, getLocation, getPathMode, getRelativePath, getUniqueName, hooks, importModule, isExtensionAllowed, isPromise, isPromiseFulfilledResult, isPromiseRejectedResult, jsStringEscape, pluginName as name, nameSorter, normalizeDirectory, pluginName, randomColour, randomPicoColour, read, readSync, renderTemplate, throttle, timeout, transformReservedWord, uniqueIdFactory, write };
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbUserPlugin<T>> : KubbUserPlugin<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => ReturnType<KubbPluginFactory<T>>;
+type Options = {
+    config: PluginContext['config'];
+    fileManager: FileManager;
+    pluginManager: PluginManager;
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
+    logger: PluginContext['logger'];
+    getPlugins: () => KubbPlugin[];
+    plugin: KubbPlugin;
+};
+type CorePluginOptions = PluginFactoryOptions<'core', Options, false, PluginContext>;
+declare const pluginName: CorePluginOptions['name'];
+
+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 };