@kubb/core 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -1,5 +1,10 @@
+import { Ora } from 'ora';
 import { DirectoryTreeOptions } from 'directory-tree';
 
+declare function isPromise<T>(result: MaybePromise<T>): result is Promise<T>;
+
+declare function write(data: string, path: string): Promise<void>;
+
 interface Cache<T extends object = object> {
     delete(id: keyof T): boolean;
     get(id: keyof T): T[keyof T] | null;
@@ -8,9 +13,274 @@ interface Cache<T extends object = object> {
 }
 declare function createPluginCache<T extends Record<string, [number, unknown]>>(cache: T): Cache<T>;
 
+declare function getRelativePath(rootDir?: string | null, filePath?: string | null): string;
+type PathMode = 'file' | 'directory';
+declare function getPathMode(path: string | undefined | null): PathMode;
+declare function read(path: string): Promise<string>;
+
+declare function isURL(data: string): boolean;
+
+type Data = string[][];
+type Options$2 = {
+    typed?: boolean;
+};
+declare function objectToParameters(data: Data, options?: Options$2): string;
+
+declare function nameSorter<T extends {
+    name: string;
+}>(a: T, b: T): 1 | -1 | 0;
+
+declare function createJSDocBlockText({ comments }: {
+    comments: Array<string>;
+}): string;
+
+declare function getUniqueName(originalName: string, data: Record<string, number>): string;
+
+declare function timeout(ms: number): Promise<unknown>;
+
+type QueueTask<T = unknown> = {
+    (...args: unknown[]): Promise<T>;
+};
+declare class Queue {
+    private readonly queue;
+    workerCount: number;
+    private maxParallel;
+    constructor(maxParallel: number);
+    run<T>(task: QueueTask<T>): Promise<T>;
+    private work;
+}
+
+declare function getEncodedText(text?: string): string;
+
+declare function renderTemplate<TData extends Record<string, string> = Record<string, string>>(template: string, data?: TData | undefined): string;
+
+declare function clean(path: string): Promise<boolean>;
+
+type TreeNodeOptions = DirectoryTreeOptions;
+declare class TreeNode<T = unknown> {
+    data: T;
+    parent?: TreeNode<T>;
+    children: Array<TreeNode<T>>;
+    constructor(data: T, parent?: TreeNode<T>);
+    addChild(data: T): TreeNode<T>;
+    find(data: T): {} | null;
+    leaves(): TreeNode<T>[];
+    root(): TreeNode<T>;
+    forEach(callback: (treeNode: TreeNode<T>) => void): this;
+    static build<T = unknown>(path: string, options?: TreeNodeOptions): TreeNode<T> | null;
+}
+
+declare function transformReservedWord(word?: string | null): string | null | undefined;
+
+declare function getStackTrace(belowFn?: Function): NodeJS.CallSite[];
+
+type Import = {
+    name: string | string[];
+    path: string;
+    isTypeOnly?: boolean;
+};
+type Export = {
+    name?: string | string[];
+    path: string;
+    isTypeOnly?: boolean;
+    asAlias?: boolean;
+};
+type File = {
+    /**
+     * Name to be used to dynamicly create the fileName(based on input.path)
+     */
+    fileName: string;
+    /**
+     * Path will be full qualified path to a specified file
+     */
+    path: string;
+    source: string;
+    imports?: Import[];
+    exports?: Export[];
+    /**
+     * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
+     * @default `false`
+     */
+    override?: boolean;
+    meta?: {
+        pluginName?: string;
+    };
+};
+type UUID = string;
+type CacheStore = {
+    id: UUID;
+    file: File;
+    status: Status;
+};
+type Status = 'new' | 'success' | 'removed';
+
+declare class FileManager {
+    private cache;
+    private task?;
+    private queue?;
+    constructor(options?: {
+        queue: Queue;
+        task: QueueTask<unknown>;
+    });
+    private getCache;
+    getCacheByPath(path: string | undefined): CacheStore | undefined;
+    get files(): File[];
+    add(file: File): Promise<File>;
+    addOrAppend(file: File): Promise<File>;
+    setStatus(id: UUID, status: Status): void;
+    get(id: UUID): File | undefined;
+    remove(id: UUID): void;
+    write(...params: Parameters<typeof write>): Promise<void>;
+    read(...params: Parameters<typeof read>): Promise<string>;
+}
+
+declare function writeIndexes(root: string, options: TreeNodeOptions): File[] | undefined;
+declare function combineFiles(files: Array<File | null>): File[];
+declare function getFileSource(file: File): string;
+
+/**
+ * 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 Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
+type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+    strategy: Strategy;
+    hookName: H;
+    plugin: KubbPlugin;
+};
+type OnExecute<H extends PluginLifecycleHooks = PluginLifecycleHooks> = (this: PluginManager, executer: Executer<H> | undefined) => void;
+
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbPlugin<T>> : KubbPlugin<T>;
+declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => T["nested"] extends true ? KubbPlugin<T>[] : KubbPlugin<T>;
+type Options$1 = {
+    config: PluginContext['config'];
+    fileManager: FileManager;
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
+    load: PluginContext['load'];
+    getExecuter: () => Executer<PluginLifecycleHooks> | undefined;
+};
+type CorePluginOptions = PluginFactoryOptions<Options$1, false, PluginContext>;
+declare const name: "core";
+
+declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<unknown, false, any, Record<string, any>>>];
+type Options = {
+    task: QueueTask;
+    onExecute?: OnExecute<PluginLifecycleHooks>;
+};
+declare class PluginManager {
+    plugins: KubbPlugin[];
+    readonly fileManager: FileManager;
+    private readonly onExecute?;
+    readonly core: KubbPlugin<CorePluginOptions>;
+    queue: Queue;
+    executer: Executer | undefined;
+    executed: Executer[];
+    constructor(config: KubbConfig, options: Options);
+    getExecuter(): Executer | undefined;
+    resolvePath: (params: ResolvePathParams) => OptionalPath;
+    resolveName: (params: ResolveNameParams) => string | null;
+    load: (id: string) => Promise<TransformResult>;
+    /**
+     *
+     * Run only hook for a specific plugin name
+     */
+    hookForPlugin<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+    }): Promise<ReturnType<PluginLifecycle[H]> | null> | null;
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+    }): ReturnType<PluginLifecycle[H]> | null;
+    /**
+     *
+     * Chains, first non-null result stops and returns
+     */
+    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): Promise<ReturnType<PluginLifecycle[H]>>;
+    /**
+     *
+     * Chains, first non-null result stops and returns
+     */
+    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): ReturnType<PluginLifecycle[H]>;
+    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
+        hookName: H;
+        parameters?: Parameters<PluginLifecycle[H]> | undefined;
+    }): Promise<Awaited<TOuput>[]>;
+    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
+    }): Promise<Argument0<H>>;
+    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
+        hookName: H;
+        parameters?: Parameters<PluginLifecycle[H]>;
+    }): Promise<void>;
+    private getSortedPlugins;
+    private getPlugin;
+    private addExecuter;
+    /**
+     * Run an async plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The actual pluginObject to run.
+     */
+    private execute;
+    /**
+     * Run a sync plugin hook and return the result.
+     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+     * @param args Arguments passed to the plugin hook.
+     * @param plugin The acutal plugin
+     * @param replaceContext When passed, the plugin context can be overridden.
+     */
+    private executeSync;
+    private catcher;
+}
+
+declare class ValidationPluginError extends Error {
+}
+declare function validatePlugins(plugins: KubbPlugin[], dependedPluginNames: string | string[]): true;
+
+declare class PluginError extends Error {
+    pluginManager: PluginManager;
+    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;
+    });
+}
+
 interface Register {
 }
 type MaybePromise<T> = Promise<T> | T;
+/**
+ * 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
@@ -79,9 +349,26 @@ type KubbConfig = {
     logLevel?: LogLevel;
 };
 type CLIOptions = {
+    /**
+     * Path to `kubb.config.js`
+     */
     config?: string;
+    /**
+     * Enable debug mode
+     */
     debug?: boolean;
+    /**
+     * Watch changes on input
+     */
     watch?: string;
+    /**
+     * Override input defined in `kubb.config.js`
+     */
+    input?: string;
+};
+type BuildOutput = {
+    files: FileManager['files'];
+    pluginManager: PluginManager;
 };
 type KubbPluginKind = 'schema' | 'controller';
 type KubbJSONPlugin = [plugin: keyof Register | string, options: Register[keyof Register] | object];
@@ -106,7 +393,7 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
      */
     api?: TOptions['api'];
     /**
-     * Options set for a specific plugin(see kubb.config.ts)
+     * Options set for a specific plugin(see kubb.config.js)
      */
     options?: TOptions['options'];
 } & Partial<PluginLifecycle<TOptions>>;
@@ -190,7 +477,7 @@ type PluginContext<TOptions = Record<string, any>> = {
     fileManager: FileManager;
     addFile: (...file: File[]) => Promise<File[]>;
     resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath;
-    resolveName: (params: ResolveNameParams) => string;
+    resolveName: (params: ResolveNameParams) => string | null | undefined;
     load: (id: string) => MaybePromise<TransformResult | void>;
 };
 type TransformResult = string | null;
@@ -203,265 +490,23 @@ type FileName = string | null | undefined;
 type LogType = 'error' | 'warn' | 'info';
 type LogLevel = LogType | 'silent';
 
-declare function isPromise<T>(result: MaybePromise<T>): result is Promise<T>;
-
-declare function write(data: string, path: string): Promise<void>;
-
-declare function getRelativePath(rootDir?: string | null, filePath?: string | null): string;
-type PathMode = 'file' | 'directory';
-declare function getPathMode(path: string | undefined | null): PathMode;
-declare function read(path: string): Promise<string>;
-
-declare function isURL(data: string): boolean;
-
-type Data = string[][];
-type Options$1 = {
-    typed?: boolean;
-};
-declare function objectToParameters(data: Data, options?: Options$1): string;
-
-declare function nameSorter<T extends {
-    name: string;
-}>(a: T, b: T): 1 | -1 | 0;
-
-declare function createJSDocBlockText({ comments }: {
-    comments: Array<string>;
-}): string;
-
-declare function getUniqueName(originalName: string, data: Record<string, number>): string;
-
-declare function timeout(ms: number): Promise<unknown>;
-
-type QueueTask<T = unknown> = {
-    (...args: unknown[]): Promise<T>;
-};
-declare class Queue {
-    private readonly queue;
-    workerCount: number;
-    private maxParallel;
-    constructor(maxParallel: number);
-    run<T>(task: QueueTask<T>): Promise<T>;
-    private work;
-}
-
-declare function getEncodedText(text?: string): string;
-
-declare function renderTemplate<TData extends Record<string, string> = Record<string, string>>(template: string, data?: TData | undefined): string;
-
-declare function clean(path: string): Promise<unknown>;
-
-type TreeNodeOptions = DirectoryTreeOptions;
-declare class TreeNode<T = unknown> {
-    data: T;
-    parent?: TreeNode<T>;
-    children: Array<TreeNode<T>>;
-    constructor(data: T, parent?: TreeNode<T>);
-    addChild(data: T): TreeNode<T>;
-    find(data: T): {} | null;
-    leaves(): TreeNode<T>[];
-    root(): TreeNode<T>;
-    forEach(callback: (treeNode: TreeNode<T>) => void): this;
-    static build<T = unknown>(path: string, options?: TreeNodeOptions): TreeNode<T> | null;
-}
-
-declare function transformReservedWord(word: string): string;
-
-type Import = {
-    name: string | string[];
-    path: string;
-    isTypeOnly?: boolean;
-};
-type Export = {
-    name?: string | string[];
-    path: string;
-    isTypeOnly?: boolean;
-    asAlias?: boolean;
-};
-type File = {
-    /**
-     * Name to be used to dynamicly create the fileName(based on input.path)
-     */
-    fileName: string;
-    /**
-     * Path will be full qualified path to a specified file
-     */
-    path: string;
-    source: string;
-    imports?: Import[];
-    exports?: Export[];
-    /**
-     * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
-     * @default `false`
-     */
-    override?: boolean;
-};
-type UUID = string;
-type CacheStore = {
-    id: UUID;
-    file: File;
-    status: Status;
-};
-type Status = 'new' | 'success' | 'removed';
-
-declare class FileManager {
-    private cache;
-    private task?;
-    private queue?;
-    constructor(options?: {
-        queue: Queue;
-        task: QueueTask<unknown>;
-    });
-    private getCache;
-    getCacheByPath(path: string | undefined): CacheStore | undefined;
-    get files(): File[];
-    add(file: File): Promise<File>;
-    addOrAppend(file: File): Promise<File>;
-    setStatus(id: UUID, status: Status): void;
-    get(id: UUID): File | undefined;
-    remove(id: UUID): void;
-    write(...params: Parameters<typeof write>): Promise<void>;
-    read(...params: Parameters<typeof read>): Promise<string>;
-}
-
-declare function writeIndexes(root: string, options: TreeNodeOptions): File[] | undefined;
-declare function combineFiles(files: Array<File | null>): File[];
-declare function getFileSource(file: File): string;
-
-type BuildOutput = {
-    files: FileManager['files'];
-};
-type Spinner = {
-    start: (text?: string) => Spinner;
-    succeed: (text: string) => Spinner;
-    fail: (text?: string) => Spinner;
-    stopAndPersist: (options: {
-        text: string;
-    }) => Spinner;
-    render: () => Spinner;
-    text: string;
-    info: (text: string) => Spinner;
-};
 type Logger = {
     log: (message: string, logLevel: LogLevel) => void;
-    spinner?: Spinner;
+    spinner?: Ora;
 };
 type BuildOptions = {
     config: PluginContext['config'];
     logger?: Logger;
 };
-type KubbBuild = (options: BuildOptions) => Promise<BuildOutput>;
 declare function build(options: BuildOptions): Promise<BuildOutput>;
 
 /**
- * Type helper to make it easier to use kubb.config.ts
+ * 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 const defineConfig: (options: MaybePromise<KubbUserConfig> | ((cliOptions: CLIOptions) => MaybePromise<KubbUserConfig>)) => MaybePromise<KubbUserConfig> | ((cliOptions: CLIOptions) => MaybePromise<KubbUserConfig>);
 
-type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => T['nested'] extends true ? Array<KubbPlugin<T>> : KubbPlugin<T>;
-declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>): (options: T['options']) => T["nested"] extends true ? KubbPlugin<T>[] : KubbPlugin<T>;
-type Options = {
-    config: PluginContext['config'];
-    fileManager: FileManager;
-    resolvePath: PluginContext['resolvePath'];
-    resolveName: PluginContext['resolveName'];
-    load: PluginContext['load'];
-};
-type CorePluginOptions = PluginFactoryOptions<Options, false, PluginContext>;
-declare const name: "core";
-
-/**
- * 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 Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq';
-
-declare const hooks: [keyof PluginLifecycle<PluginFactoryOptions<unknown, false, any, Record<string, any>>>];
-declare class PluginManager {
-    plugins: KubbPlugin[];
-    readonly fileManager: FileManager;
-    private readonly logger?;
-    private readonly config;
-    readonly core: KubbPlugin<CorePluginOptions>;
-    queue: Queue;
-    constructor(config: KubbConfig, options: {
-        logger?: Logger;
-        task: QueueTask;
-    });
-    resolvePath: (params: ResolvePathParams) => OptionalPath;
-    resolveName: (params: ResolveNameParams) => string;
-    load: (id: string) => Promise<TransformResult>;
-    /**
-     *
-     * Run only hook for a specific plugin name
-     */
-    hookForPlugin<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
-        pluginName: string;
-        hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
-    }): Promise<ReturnType<PluginLifecycle[H]> | null>;
-    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
-        pluginName: string;
-        hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
-    }): ReturnType<PluginLifecycle[H]>;
-    /**
-     *
-     * Chains, first non-null result stops and returns
-     */
-    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
-        hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
-        skipped?: ReadonlySet<KubbPlugin> | null;
-    }): Promise<ReturnType<PluginLifecycle[H]>>;
-    /**
-     *
-     * Chains, first non-null result stops and returns
-     */
-    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
-        hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
-        skipped?: ReadonlySet<KubbPlugin> | null;
-    }): ReturnType<PluginLifecycle[H]>;
-    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
-        hookName: H;
-        parameters?: Parameters<PluginLifecycle[H]> | undefined;
-    }): Promise<Awaited<TOuput>[]>;
-    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
-        hookName: H;
-        parameters: Parameters<PluginLifecycle[H]>;
-        reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
-    }): Promise<Argument0<H>>;
-    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
-        hookName: H;
-        parameters?: Parameters<PluginLifecycle[H]>;
-    }): Promise<void>;
-    private getSortedPlugins;
-    private getPlugin;
-    /**
-     * Run an async plugin hook and return the result.
-     * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-     * @param args Arguments passed to the plugin hook.
-     * @param plugin The actual pluginObject to run.
-     */
-    private run;
-    /**
-     * Run a sync plugin hook and return the result.
-     * @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-     * @param args Arguments passed to the plugin hook.
-     * @param plugin The acutal plugin
-     * @param replaceContext When passed, the plugin context can be overridden.
-     */
-    private runSync;
-    private catcher;
-}
-
-declare class ValidationPluginError extends Error {
-}
-declare function validatePlugins(plugins: KubbPlugin[], dependedPluginNames: string | string[]): true;
-
 /**
  * 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
@@ -480,4 +525,4 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-export { Argument0, CLIOptions, Cache, CacheStore, CorePluginOptions, File, FileManager, FileName, Generator, KubbBuild, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, OptionalPath, Path, PathMode, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
+export { Argument0, BuildOutput, CLIOptions, Cache, CacheStore, CorePluginOptions, Executer, File, FileManager, FileName, Generator, KubbConfig, KubbJSONPlugin, KubbObjectPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, OnExecute, OptionalPath, ParallelPluginError, Path, PathMode, PluginContext, PluginError, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, Register, ResolveNameParams, ResolvePathParams, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };