@remotex-labs/xbuild 1.5.5 → 1.5.7

package/dist/cli.d.ts

@@ -1,5 +1,2779 @@
 #!/usr/bin/env node
+import type { SourceService } from "@remotex-labs/xmap";
+import type { Loader, OnLoadArgs, BuildResult, OnEndResult, PluginBuild, OnLoadResult, OnResolveArgs, OnResolveResult, BuildOptions, Format, Metafile, Message } from "esbuild";
+import type { IncomingMessage, ServerResponse } from "http";
+import type { Argv } from "yargs";
+import type { ChildProcessWithoutNullStreams } from "child_process";
+import type { ParsedCommandLine } from "typescript";
+import type { Context } from "vm";
 /**
- * Import will remove at compile time
+ * Represents an enhanced error type that extends the built-in Error object.
+ * This type adds an optional property to store call stack information.
+ *
+ * @type ErrorType
+ *
+ * @extends Error
+ *
+ * @property callStacks - An optional array of call sites
+ *   captured when the error was created. This can provide additional context
+ *   regarding the call stack at the time of the error, useful for debugging.
+ *
+ * @example
+ * ```ts
+ * const myError: ErrorType = new Error("Something went wrong!");
+ * myError.callStacks = getCallStack(); // Assuming getCallStack captures call sites.
+ * console.error(myError);
+ * ```
  */
-export {};
+export type ErrorType = Error & {
+    callStacks?: Array<NodeJS.CallSite>;
+};
+/**
+ * Represents the state of a stack trace, containing information about the error, associated code, and formatted error message.
+ *
+ * @interface StackTraceStateInterface
+ * @property error - The error object with attached `callStacks`.
+ * @property blockCode - The block of code (if any) related to the error, or `null` if unavailable.
+ * @property formattedError - A formatted string representing the error details.
+ */
+export interface StackTraceStateInterface {
+    error: ErrorType & BaseError;
+    blockCode: null | string;
+    formattedError: string;
+}
+/**
+ * Represents detailed information about a specific frame in the call stack.
+ *
+ * @interface FrameDetailsInterface
+ * @property line - The line number where the frame occurred.
+ * @property column - The column number where the frame occurred.
+ * @property source - The source file path where the frame occurred.
+ * @property functionName - The name of the function being executed at this frame, or an empty string if not available.
+ */
+export interface FrameDetailsInterface {
+    line: number;
+    column: number;
+    source: string;
+    functionName: string;
+}
+/**
+ * An enumeration of ANSI color codes used for text formatting in the terminal.
+ *
+ * These colors can be used to format terminal output with various text colors,
+ * including different shades of gray, yellow, and orange, among others.
+ *
+ * Each color code starts with an ANSI escape sequence (`\u001B`), followed by the color code.
+ * The `Reset` option can be used to reset the terminal's text formatting back to the default.
+ *
+ * @example
+ * ```ts
+ * console.log(Color.BrightPink, 'This is bright pink text', Color.Reset);
+ * ```
+ */
+export declare const enum Colors {
+    Reset = "\u001B[0m",
+    Red = "\u001B[38;5;9m",
+    Gray = "\u001B[38;5;243m",
+    Cyan = "\u001B[38;5;81m",
+    DarkGray = "\u001B[38;5;238m",
+    LightCoral = "\u001B[38;5;203m",
+    LightOrange = "\u001B[38;5;215m",
+    OliveGreen = "\u001B[38;5;149m",
+    BurntOrange = "\u001B[38;5;208m",
+    LightGoldenrodYellow = "\u001B[38;5;221m",
+    LightYellow = "\u001B[38;5;230m",
+    CanaryYellow = "\u001B[38;5;227m",
+    DeepOrange = "\u001B[38;5;166m",
+    LightGray = "\u001B[38;5;252m",
+    BrightPink = "\u001B[38;5;197m"
+}
+/**
+ * Formats a message string with the specified ANSI color and optionally resets it after the message.
+ *
+ * This function applies an ANSI color code to the provided message,
+ * and then appends the reset code to ensure that the color formatting doesn't extend beyond the message.
+ * It's useful for outputting colored text in a terminal. If color formatting is not desired,
+ * the function can return the message unformatted.
+ *
+ * @param color - The ANSI color code to apply. This is used only if `activeColor` is true.
+ * @param msg - The message to be formatted with the specified color.
+ * @param activeColor - A boolean flag indicating whether color formatting should be applied. Default is `__ACTIVE_COLOR`.
+ *
+ * @returns A string with the specified color applied to the message,
+ * followed by a reset sequence if `activeColor` is true.
+ *
+ * @example
+ * ```ts
+ * const coloredMessage = setColor(Colors.LightOrange, 'This is a light orange message');
+ * console.log(coloredMessage);
+ * ```
+ *
+ * @example
+ * ```ts
+ * const plainMessage = setColor(Colors.LightOrange, 'This is a light orange message', false);
+ * console.log(plainMessage); // Output will be without color formatting
+ * ```
+ */
+export declare function setColor(color: Colors, msg: string, activeColor?: boolean): string;
+export declare const xBuildLazy: {
+    readonly service: SourceService;
+};
+/**
+ * Prepares the error stack trace for display.
+ *
+ * This function overrides the default stack trace preparation to provide a custom format,
+ * including enhanced stack trace information and error details.
+ *
+ * @param error - The error object (Error or BaseError).
+ * @param stackEntries - The array of stack entries from the call stack.
+ * @returns The formatted stack trace as a string.
+ */
+export declare function formatStackTrace(error: ErrorType & BaseError, stackEntries: Array<NodeJS.CallSite>): string;
+/**
+ * A base class for custom errors with enhanced stack trace formatting and source code information.
+ *
+ * The `BaseError` class extends the native `Error` class, adding functionality to format the error stack
+ * trace and include details from a source map service. This is useful for debugging errors in compiled
+ * or transpiled code by providing clearer information about the source of the error.
+ */
+export declare abstract class BaseError extends Error {
+    readonly sourceMap?: SourceService | undefined;
+    callStacks: Array<NodeJS.CallSite>;
+    /**
+     * Creates a new instance of `BaseError`.
+     *
+     * This constructor initializes a new `BaseError` instance by setting the error message and formatting
+     * the stack trace using the provided source map information. It also ensures the stack trace is maintained
+     * correctly by using `Error.captureStackTrace` (if available). The default source map service is used if
+     * none is provided.
+     *
+     * @param message - A descriptive error message to be associated with the error.
+     * @param sourceMap - (Optional) The `SourceService` instance used to format and resolve the stack trace.
+     *                    If not provided, the default source map service (`defaultSourceService`) is used.
+     */
+    protected constructor(message: string, sourceMap?: SourceService | undefined);
+    /**
+     * Reformats the error stack trace using source map information.
+     *
+     * This function enhances the original error stack trace by attempting to map each entry
+     * back to its original position in the source file using the provided source map service.
+     * If the source map information is not available, it returns the original stack trace.
+     *
+     * @param error - The original error with stack trace of the error.
+     * @returns The reformatted stack trace or the original stack trace if no mapping is available.
+     */
+    protected reformatStack(error: ErrorType): string;
+}
+/**
+ * Represents an error specific to the xBuild process.
+ *
+ * The `xBuildError` class extends the `BaseError` class to provide a custom error type for the xBuild system.
+ * It includes additional functionality to maintain stack trace information and assigns a specific name to
+ * the error, making it easier to identify and handle in different parts of the application.
+ *
+ * @augments BaseError
+ */
+export declare class xBuildError extends BaseError {
+    /**
+     * Original error stack
+     */
+    originalErrorStack: string | undefined;
+    /**
+     * Creates an instance of `xBuildError`.
+     *
+     * @param message - The error message that describes the error. This message is passed to the base class
+     *   `BaseError` constructor and is used to provide context about the nature of the error.
+     * @param options - Optional configuration for the error. This can include additional properties or settings
+     *   that customize the error's behavior.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * A custom error class to handle errors occurring within a virtual machine (VM) execution context.
+ *
+ * The `VMRuntimeError` class extends the native `Error` class and enhances the error with
+ * source map information to map stack traces back to the original source. This is particularly
+ * useful when debugging errors from code executed in a `vm` or `evalmachine` environment.
+ *
+ * @param message - The error message describing the error.
+ * @param originalError - The original error object thrown from the VM execution.
+ * @param sourceMap - The `SourceService` providing source map data to link the error to its original source.
+ *
+ * @example
+ * ```ts
+ * try {
+ *    vm.run(someCode);
+ * } catch (error) {
+ *    throw new VMRuntimeError("VM execution failed", error, sourceMapService);
+ * }
+ * ```
+ */
+export declare class VMRuntimeError extends BaseError {
+    /**
+     * The original error thrown during the VM execution.
+     */
+    originalError: Error;
+    /**
+     * Original error stack
+     */
+    originalErrorStack: string | undefined;
+    /**
+     * Creates a new VMRuntimeError instance.
+     *
+     * This constructor initializes a new `VMRuntimeError` object, extending the native `Error` class with
+     * additional information, including the original error and optional source map data. It also ensures that
+     * the stack trace is correctly captured and reformatted using the source map (if provided) to enhance
+     * debugging.
+     *
+     * @param originalError - The original error object that was thrown during the VM execution.
+     * @param sourceMap - (Optional) The source map service used to map the error stack trace to its original
+     *                    source code locations. If not provided, this will be `null`.
+     *
+     * @example
+     * ```ts
+     * try {
+     *    vm.run(code);
+     * } catch (error) {
+     *    throw new VMRuntimeError(error, sourceMapService);
+     * }
+     * ```
+     */
+    constructor(originalError: ErrorType, sourceMap?: SourceService);
+}
+/**
+ * Interface for the build state that users can modify.
+ *
+ * This interface allows users to store and manage any custom data related to the build process.
+ *
+ * @template T - The type of values that can be stored in the state.
+ */
+export interface BuildState {
+    [key: string]: unknown;
+}
+/**
+ * A type that defines the possible return values of a plugin function.
+ *
+ * The function can return a Promise that resolves to `null` or `void`, or it can return `null` or `void` directly.
+ */
+export type pluginResultType = Promise<null | void> | null | void;
+/**
+ * Defines the signature of a function that is called at the end of the build process.
+ *
+ * @param result - The `BuildResult` object that contains information about the outcome of the build process.
+ * @param state - The current build state that users can modify.
+ * @returns A `pluginResultType`, which may include asynchronous operations.
+ */
+export type OnEndType = (result: BuildResult, state: BuildState) => pluginResultType | OnEndResult | Promise<OnEndResult>;
+/**
+ * Defines the signature of a function that is called at the start of the build process.
+ *
+ * @param build - The `PluginBuild` object that contains information about the build process and allows modifying build options.
+ * @param state - The current build state that users can modify.
+ * @returns A `pluginResultType`, which may include asynchronous operations.
+ */
+export type OnStartType = (build: PluginBuild, state: BuildState) => pluginResultType | OnEndResult | Promise<OnEndResult>;
+/**
+ * Defines the signature of a function that is called during the resolution of an import path.
+ *
+ * @param args - The `OnResolveArgs` object, containing information about the file being resolved, such as its path, importer, namespace, etc.
+ * @param state - The current build state that users can modify.
+ * @returns A `Promise` or a direct `OnResolveResult` which can modify the resolved path, or a `pluginResultType` for
+ * performing additional async tasks without altering resolution.
+ */
+export type OnResolveType = (args: OnResolveArgs, state: BuildState) => Promise<OnResolveResult | pluginResultType> | OnResolveResult | pluginResultType;
+/**
+ * Defines the signature of a function that is called when a file is loaded.
+ *
+ * @param content - The content of the file being loaded, as either a `string` or `Uint8Array`.
+ * @param loader - The type of loader used for the file, such as `js`, `ts`, `json`, or others. It can also be `undefined`.
+ * @param args - The `OnLoadArgs` object, containing information about the file being loaded, such as its path, namespace, etc.
+ * @param state - The current build state that users can modify.
+ * @returns A `Promise` or direct `OnLoadResult`, which can modify the file content and loader, or a `pluginResultType`
+ * for performing additional async tasks without altering the content.
+ */
+export type OnLoadType = (content: string | Uint8Array, loader: Loader | undefined, args: OnLoadArgs, state: BuildState) => Promise<OnLoadResult | pluginResultType> | OnLoadResult | pluginResultType;
+/**
+ * Represents the format for specifying entry points in TypeScript declaration generation.
+ *
+ * This type allows for various formats to specify the entry points from which TypeScript declaration files should be generated.
+ * The supported formats are:
+ * - `Array<string>`: An array of file paths as strings. Each string represents a path to a TypeScript entry point file.
+ * - `Record<string, string>`: An object where each key-value pair represents an entry point.
+ *
+ * The key is a name or identifier, and the value is the file path to the TypeScript entry point.
+ * - `Array<{ in: string, out: string }>`: An array of objects, where each object specifies an input file path (`in`)
+ * and an output file path (`out`). This format allows for specifying where each entry point file is located and
+ * where its corresponding declaration file should be output.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * const entryPoints1: EntryPoints = ['src/index.ts', 'src/utils.ts'];
+ * const entryPoints2: EntryPoints = { main: 'src/index.ts', utils: 'src/utils.ts' };
+ * const entryPoints3: EntryPoints = [{ in: 'src/index.ts', out: 'dist/index.d.ts' }, { in: 'src/utils.ts', out: 'dist/utils.d.ts' }];
+ * ```
+ */
+export type EntryPoints = Array<string> | Record<string, string> | Array<{
+    in: string;
+    out: string;
+}> | undefined;
+/**
+ * Represents a deeply nested partial version of a given type `T`.
+ *
+ * This type utility allows for partial objects at any level of nesting.
+ * It recursively makes all properties optional and applies the same behavior to nested objects.
+ *
+ * **Example Usage:**
+ *
+ * ```ts
+ * interface User {
+ *     name: string;
+ *     address: {
+ *         street: string;
+ *         city: string;
+ *     };
+ * }
+ *
+ * // PartialDeep<User> will allow the following:
+ * const partialUser: PartialDeep<User> = {
+ *     name: 'Alice',        // 'name' is optional
+ *     address: {
+ *         city: 'Wonderland' // 'street' is optional
+ *     }
+ * };
+ * ```
+ *
+ * @template T - The type to be made partially optional and deeply nested.
+ *
+ * @typeParam T - The base type to apply the partial transformation.
+ *
+ * @example
+ * ```
+ * type MyPartial = PartialDeep<{ a: number; b: { c: string; d: { e: boolean } } }>;
+ * // MyPartial will be equivalent to:
+ * // {
+ * //   a?: number;
+ * //   b?: {
+ * //     c?: string;
+ * //     d?: {
+ * //       e?: boolean;
+ * //     }
+ * //   }
+ * // }
+ * ```
+ */
+export type PartialDeep<T> = {
+    [P in keyof T]?: T[P] extends object ? PartialDeep<T[P]> : T[P];
+};
+/**
+ * Represents a module with its exports and an optional default export.
+ *
+ * This interface provides a structure to define and interact with the exports of a module.
+ * It includes both named and default exports, where default exports are of a specific type.
+ *
+ * @interface ModuleInterface
+ *
+ * @property exports - An object representing the exports of the module.
+ * The keys are strings that represent the names of the exports, and the values can be of any type.
+ *
+ * @property exports[key: string] - A dictionary where each key is a string representing the export name,
+ * and the associated value can be of any type.
+ *
+ * @property [exports.default] - An optional default export.
+ * The default export, if present, is of type `ConfigurationInterface`.
+ */
+export interface ModuleInterface {
+    /**
+     * An object representing the exports of the module.
+     * The keys are strings representing export names, and the values can be of any type.
+     *
+     * @property default - An optional default export of type `ConfigurationInterface`.
+     */
+    exports: {
+        [key: string]: unknown;
+        default?: ConfigurationInterface;
+    };
+}
+/**
+ * Configuration options for the serve the build.
+ *
+ * This object allows you to specify various settings related to the server,
+ * such as the port, host, SSL/TLS certificates, and request handling functions.
+ *
+ * @example
+ * ```ts
+ * const serverConfig = {
+ *     serve: {
+ *         active: true,
+ *         port: 8080,
+ *         host: 'localhost',
+ *         keyfile: '/path/to/ssl/keyfile.pem',
+ *         certfile: '/path/to/ssl/certfile.pem',
+ *         onStart: () => {
+ *             console.log('Server started');
+ *         }
+ *         onRequest: (req, res, next) => {
+ *             console.log('Server request received');
+ *             next();
+ *         }
+ *     }
+ * };
+ * ```
+ *
+ * @public
+ */
+export interface Serve {
+    port: number;
+    host: string;
+    active: boolean;
+    keyfile?: string;
+    certfile?: string;
+    onRequest?: (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+    onStart?: () => void;
+}
+/**
+ * Defines the lifecycle hooks used in the plugin system.
+ *
+ * This interface specifies the types for various hooks that can be registered
+ * to customize the behavior of the build process. Each hook corresponds to a
+ * specific stage in the lifecycle of an esbuild operation.
+ *
+ * @interface hooks
+ *
+ * @property onEnd - A hook function that is called after the build process completes.
+ *                               This allows for post-processing or cleanup tasks.
+ * @property onLoad - A hook function that is called when esbuild attempts to load a module.
+ *                                 It can be used to modify the contents of the loaded module.
+ * @property onStart - A hook function that is called before the build process starts.
+ *                                    This is useful for initialization tasks or logging.
+ * @property onResolve - A hook function that is called when esbuild attempts to resolve a module path.
+ *                                        It can be used to customize module resolution behavior.
+ *
+ * @example
+ * ```ts
+ * const myHooks: hooks = {
+ *     onEnd: async (result) => {
+ *         console.log('Build finished:', result);
+ *     },
+ *     onLoad: async (contents, loader, args) => {
+ *         // Modify contents if necessary
+ *         return { contents, loader };
+ *     },
+ *     onStart: async (build) => {
+ *         console.log('Build started:', build);
+ *     },
+ *     onResolve: async (args) => {
+ *         if (args.path === 'my-module') {
+ *             return { path: './src/my-module.ts' };
+ *         }
+ *         return null;
+ *     }
+ * };
+ * ```
+ *
+ * @see OnEndType
+ * @see OnLoadType
+ * @see OnStartType
+ * @see OnResolveType
+ */
+export interface hooks {
+    onEnd: OnEndType;
+    onLoad: OnLoadType;
+    onStart: OnStartType;
+    onSuccess: OnEndType;
+    onResolve: OnResolveType;
+}
+/**
+ * Represents the configuration options for the build and development process.
+ *
+ * This interface defines various settings that control how the application is built and run, including development mode,
+ * file watching, TypeScript declaration generation, error handling, TypeScript type checking, and esbuild bundler options.
+ *
+ * @example
+ * ```ts
+ * const config: ConfigurationInterface = {
+ *     dev: true,
+ *     watch: true,
+ *     declaration: true,
+ *     buildOnError: false,
+ *     noTypeChecker: false,
+ *     esbuild: {
+ *         entryPoints: ['./src/index.ts'],
+ *         bundle: true,
+ *         minify: true,
+ *         target: 'es2020'
+ *     },
+ *     hooks: {
+ *         onStart: async (build) => {
+ *             console.log('Build started');
+ *         },
+ *         onEnd: async (result) => {
+ *             console.log('Build finished:', result);
+ *         }
+ *     }
+ * };
+ * ```
+ *
+ * In this example, the configuration sets the application to development mode with file watching enabled,
+ * generates TypeScript declaration files, continues building on TypeScript errors, and includes esbuild options for bundling and minification.
+ * Additionally, custom hooks are provided to log messages at the start and end of the build process.
+ *
+ * @public
+ * @category Configuration
+ */
+export interface ConfigurationInterface {
+    /**
+     * Build and run entryPoint for development
+     */
+    dev: boolean | Array<string>;
+    /**
+     * Enables watching for file changes during development.
+     */
+    watch: boolean;
+    /**
+     * The directory where the generated `package.json` file will be saved,
+     * indicating the module type (`"commonjs"` or `"module"`).
+     *
+     * - If the format is `esm`, the `package.json` file will contain `"type": "module"`.
+     * - If the format is `cjs`, the `package.json` file will contain `"type": "commonjs"`.
+     *
+     * If this field is not set (`undefined`), the `package.json` file will be saved in the
+     * `outdir` specified in the esbuild configuration.
+     *
+     * Example:
+     *
+     * ```ts
+     * {
+     *   esbuild: {
+     *     outdir: 'dist',
+     *     format: 'esm'
+     *   },
+     *   moduleTypeOutDir: 'custom/dist'
+     * }
+     * // This will create 'custom/dist/package.json' with the content: {"type": "module"}
+     *
+     * // If moduleTypeOutDir is not provided:
+     * {
+     *   esbuild: {
+     *     outdir: 'dist',
+     *     format: 'cjs'
+     *   }
+     * }
+     * // This will create 'dist/package.json' with the content: {"type": "commonjs"}
+     * ```
+     */
+    moduleTypeOutDir?: string;
+    /**
+     * Generates TypeScript declaration files.
+     */
+    declaration: boolean;
+    /**
+     * Bundle declaration file
+     */
+    bundleDeclaration: boolean;
+    /**
+     * Overrides the output directory for TypeScript declaration files (.d.ts).
+     *
+     * If this option is not set, the output directory specified in the `outDir`
+     * field of your `tsconfig.json` will be used.
+     * This allows for custom control
+     * over where the declaration files are emitted, separate from the main
+     * output directory for compiled JavaScript files.
+     *
+     * @default The `outDir` from `tsconfig.json` will be used if this is not provided.
+     */
+    declarationOutDir?: string;
+    /**
+     * Continues building even if TypeScript type errors are present.
+     */
+    buildOnError: boolean;
+    /**
+     * Skips TypeScript type checking.
+     */
+    noTypeChecker: boolean;
+    /**
+     * Options for the esbuild bundler.
+     */
+    esbuild: BuildOptions;
+    /**
+     * Option for the serve the build over http/s
+     */
+    serve: Serve;
+    /**
+     * lifecycle hooks to customize the build process.
+     *
+     * This property allows you to provide implementations for various hooks defined in the `hooks` interface.
+     * Using `Partial<hooks>` means you can specify only the hooks you want to implement,
+     * while the others will default to `undefined`.
+     */
+    hooks?: Partial<hooks>;
+    /**
+     * A dictionary of define options for the build process.
+     *
+     * This property allows you to specify global constants that can be replaced during the build process.
+     * Each key-value pair in the `define` object represents a constant where the key is the name of the
+     * constant, and the value is the string to replace it with. This is particularly useful for feature flags,
+     * environment-specific configurations, or any other value that you may want to define at compile time.
+     *
+     * @example
+     * ```ts
+     * const config: ConfigurationInterface = {
+     *     dev: true,
+     *     define: {
+     *         'process.env.NODE_ENV': 'development',
+     *         'API_URL': 'https://api.example.com'
+     *     }
+     * };
+     * ```
+     *
+     * In this example, the constants `process.env.NODE_ENV` and `API_URL` will be replaced with their
+     * corresponding values during the build, making it easy to manage different configurations across
+     * various environments.
+     *
+     * @public
+     */
+    define: Record<string, unknown>;
+    /** Documentation: https://esbuild.github.io/api/#banner */
+    banner?: {
+        [type: string]: string | (() => string);
+    };
+    /** Documentation: https://esbuild.github.io/api/#footer */
+    footer?: {
+        [type: string]: string | (() => string);
+    };
+}
+interface ExportedConfigurationInterface extends ConfigurationInterface {
+    /**
+     * Options for the esbuild bundler.
+     */
+    esbuild: Omit<BuildOptions, 'plugins' | 'define'>;
+}
+/**
+ * Type alias for a partial configuration object.
+ *
+ * This type represents a configuration where all properties of the
+ * `ConfigurationInterface` are optional. It allows for flexible configuration
+ * objects where only a subset of properties need to be specified.
+ */
+export type xBuildConfig = PartialDeep<ExportedConfigurationInterface>;
+/**
+ * Represents a partially deep configuration type based on the `ConfigurationInterface`.
+ *
+ * This type is used to define configurations that may have some properties
+ * missing or undefined. It leverages the `PartialDeep` utility type to allow
+ * for flexibility in configuration management.
+ */
+export type PartialDeepConfigurationsType = PartialDeep<ConfigurationInterface>;
+/**
+ * Defines the possible types for configurations.
+ *
+ * This type can either be a single instance of `PartialDeepConfigurationsType`
+ * or an array of such instances. This flexibility allows for configurations
+ * to be specified as a single object or as multiple objects, enabling
+ * support for various build setups.
+ *
+ * @example
+ * ```ts
+ * // A single configuration object
+ * const config: ConfigurationsType = {
+ *     esbuild: {
+ *         bundle: true,
+ *         outdir: 'dist'
+ *     }
+ * };
+ * ```
+ *
+ * @example
+ * ```ts
+ * // An array of configuration objects
+ * const configs: ConfigurationsType = [
+ *     {
+ *         esbuild: {
+ *             bundle: true,
+ *             outdir: 'dist/esm'
+ *         }
+ *     },
+ *     {
+ *         esbuild: {
+ *             bundle: false,
+ *             outdir: 'dist/cjs',
+ *             declaration: false,
+ *             noTypeChecker: true
+ *         }
+ *     }
+ * ];
+ * ```
+ */
+export type ConfigurationsType = PartialDeepConfigurationsType | Array<PartialDeepConfigurationsType>;
+/**
+ * Interface representing the command-line arguments for the build tool.
+ *
+ * @interface ArgvInterface
+ * @property typeCheck - Flag indicating if the tool should perform type checking only.
+ * @property node - Flag indicating if the build is intended for Node.js environment.
+ * @property file - The entry file(s) to build.
+ * @property dev - List of development-related options for the build.
+ * @property debug - List of debugging-related options for the build.
+ * @property serve - Flag indicating if an HTTP server should be started for the build folder.
+ * @property outdir - The output directory for the build files.
+ * @property declaration - Flag indicating if TypeScript declaration files should be generated.
+ * @property watch - Flag indicating if the build should watch for file changes.
+ * @property config - Path to the build configuration file (JavaScript or TypeScript).
+ * @property tsconfig - Path to the TypeScript configuration file to use.
+ * @property minify - Flag indicating if the code should be minified.
+ * @property bundle - Flag indicating if the code should be bundled.
+ * @property format - Defines the formats for the build output.
+ */
+export interface ArgvInterface {
+    typeCheck: boolean;
+    node: boolean;
+    file: string;
+    dev: Array<string>;
+    debug: Array<string>;
+    serve: boolean;
+    outdir: string;
+    declaration: boolean;
+    watch: boolean;
+    config: string;
+    tsconfig: string;
+    minify: boolean;
+    bundle: boolean;
+    format: Format;
+}
+/**
+ * Parses command-line arguments into an `ArgvInterface` object using `yargs`.
+ *
+ * This function configures `yargs` to handle various build-related options for a JavaScript and TypeScript toolchain.
+ * It returns an object that adheres to the `ArgvInterface` structure based on the parsed arguments.
+ *
+ * @param argv - An array of command-line arguments (e.g., `process.argv`).
+ * @returns An object representing the parsed command-line arguments.
+ *
+ * @see {@link ArgvInterface} for the structure of the returned object.
+ *
+ * @example
+ * // Example usage:
+ * const args = argvParser(process.argv);
+ * console.log(args.file); // Output: the file to build
+ * console.log(args.dev); // Output: true or false based on the --dev flag
+ */
+export declare function argvParser(argv: Array<string>): Argv<ArgvInterface>;
+/**
+ * The `BuildStateInterface` extends the `BuildState` interface to include additional properties related to the build
+ * process, specifically for handling `ifdef` conditions and function removals in macros.
+ *
+ * @interface BuildStateInterface
+ */
+export interface BuildStateInterface extends BuildState {
+    ifdef: Array<string>;
+    macros: {
+        removeFunctions: Set<string>;
+    };
+}
+/**
+ * Spawns a new Node.js process to execute the provided JavaScript file, with optional debugging support.
+ *
+ * This function creates a new Node.js process to run the specified JavaScript file with source map support enabled.
+ * It optionally starts the process in debug mode, which allows WebStorm or other debuggers to attach to the process.
+ * The output and error streams of the spawned process are captured and logged to the console.
+ *
+ * @param filePath - The path to the JavaScript file to execute.
+ * @param debug - A boolean flag to enable debugging. If `true`, the process will be started with the `--inspect-brk` option,
+ * which opens a debugger on `0.0.0.0:9229`, allowing external debuggers to attach.
+ *
+ * @returns A `ChildProcessWithoutNullStreams` object representing the spawned process.
+ * This object allows interaction with the process, including capturing its output and error streams.
+ *
+ * @remarks
+ * - The `--enable-source-maps` flag is used to enable source map support, which allows better debugging by mapping
+ *   errors and stack traces to the original source code.
+ * - If `debug` is `true`, the `--inspect-brk=0.0.0.0:9229` flag is added, starting the process in debug mode and pausing
+ *   execution until a debugger is attached.
+ * - The output (`stdout`) and error (`stderr`) streams of the spawned process are logged to the console.
+ * - The function returns a `ChildProcessWithoutNullStreams` object that can be used to interact with the spawned process,
+ *   such as handling its termination or sending input.
+ *
+ * @throws Error Throws an error if the Node.js process fails to start or if there are issues with the provided file path.
+ *
+ * @example
+ * ```ts
+ * import { spawn } from '@services/process.service';
+ *
+ * // Run without debugging
+ * const process = spawn('./path/to/script.js', false);
+ *
+ * process.on('close', (code) => {
+ *     console.log(`Process exited with code ${code}`);
+ * });
+ *
+ * // Run with debugging enabled
+ * const debugProcess = spawn('./path/to/script.js', true);
+ *
+ * debugProcess.on('close', (code) => {
+ *     console.log(`Debug process exited with code ${code}`);
+ * });
+ * ```
+ *
+ * In these examples, the `spawn` function is used to execute a JavaScript file, once in normal mode and once with debugging enabled.
+ * The process's exit code is logged when the process completes.
+ *
+ * @public
+ * @category Services
+ */
+export declare function spawn(filePath: string, debug?: boolean): ChildProcessWithoutNullStreams;
+/**
+ * Represents the result of transpiling a TypeScript file.
+ *
+ * This interface defines the structure of the output returned from a TypeScript transpilation process,
+ * including the transpiled JavaScript code and the associated source map.
+ *
+ * @property code - The transpiled JavaScript code generated from the TypeScript file.
+ * @property sourceMap - The source map associated with the transpiled JavaScript code.
+ *
+ * @remarks
+ * - The `code` property contains the JavaScript code after TypeScript transpilation.
+ * - The `sourceMap` property provides the source map that maps the transpiled JavaScript code back to the original TypeScript source.
+ * - The source map is useful for debugging as it allows developers to trace errors in the generated JavaScript back to the original TypeScript code.
+ *
+ * @example
+ * ```typescript
+ * import { transpileFileInterface } from './transpileFileInterface';
+ *
+ * const result: transpileFileInterface = {
+ *     code: 'console.log("Hello, world!");',
+ *     sourceMap: 'version: 3\nfile: out.js\nsources: ["file.ts"]\n'
+ * };
+ *
+ * console.log(result.code); // Output: console.log("Hello, world!");
+ * console.log(result.sourceMap); // Output: version: 3\nfile: out.js\nsources: ["file.ts"]\n
+ * ```
+ *
+ * In this example, the `transpileFileInterface` is used to represent the result of transpiling a TypeScript file.
+ * The `code` contains the JavaScript code, while the `sourceMap` provides the mapping information for debugging purposes.
+ *
+ * @public
+ * @category Interfaces
+ */
+export interface transpileFileInterface {
+    code: string;
+    sourceMap: string;
+}
+/**
+ * Default build options for esbuild bundler in RemoteX framework.
+ *
+ * These options are used to configure how esbuild processes and bundles the TypeScript
+ * files for the RemoteX testing framework.
+ *
+ * @public
+ * @category Configuration
+ */
+export declare const defaultBuildOptions: BuildOptions;
+/**
+ * Extracts the source map from the provided data string and returns the modified code and source map separately.
+ *
+ * This function searches for the inline source map in the data string using a regular expression, removes the
+ * source map comment from the data string, and returns an object containing the code without the source map
+ * comment and the extracted source map.
+ *
+ * @param dataString - The string containing the transpiled code with an inline source map.
+ * @returns An object containing the modified code without the source map comment and the extracted source map.
+ * @throws Error -Throws an error if the source map URL is not found in the data string.
+ *
+ * @public
+ */
+export declare function extractSourceMap(dataString: string): transpileFileInterface;
+/**
+ * Transpiles a TypeScript file and extracts the source map.
+ *
+ * This function uses esbuild to transpile the specified TypeScript file based on provided build options,
+ * and then extracts the source map from the transpiled code.
+ *
+ * @param filePath - The path to the TypeScript file to be transpiled.
+ * @param buildOptions - Optional build options to override the default build options.
+ * @returns A promise that resolves to an object containing the transpiled code and the extracted source map.
+ * @throws Error - Throws an error if the build process fails or the source map extraction fails.
+ *
+ * @public
+ * @category Services
+ */
+export declare function transpileFile(filePath: string, buildOptions?: BuildOptions): Promise<transpileFileInterface>;
+/**
+ * The `analyzeDependencies` function analyzes the dependencies of a given entry point for a specified platform.
+ * It performs a bundling operation and generates a metafile that contains detailed information about the
+ * dependencies involved in the build process.
+ * This is typically used to inspect the external packages and modules
+ * that the entry point depends on.
+ *
+ * - **Input**:
+ *   - `entryPoint`: A string or array of strings representing the entry points for the build.
+ *   This defines the starting point(s) for the bundling process.
+ *   - `platform`: An optional parameter that specifies the platform to target for the build.
+ *   Default is `'browser'`.
+ *
+ * - **Output**: A `Promise` that resolves to an object containing:
+ *   - The `BuildResult` from the bundling process.
+ *   - A `metafile`, which contains detailed metadata about the build, including the dependencies analyzed.
+ *
+ * ## Example:
+ *
+ * ```ts
+ * const result = await analyzeDependencies(['src/index.ts']);
+ * console.log(result.metafile); // { inputs: { 'src/index.ts': { ... } }, outputs: { ... } }
+ *
+ * const nodeResult = await analyzeDependencies(['src/server.ts'], 'node');
+ * console.log(nodeResult.metafile); // { inputs: { 'src/server.ts': { ... } }, outputs: { ... } }
+ * ```
+ *
+ * @param entryPoint - The entry point(s) to be analyzed.
+ * @param platform - The target platform for the build.
+ * @returns A `Promise` that resolves to a `BuildResult` object along with a `metafile` containing dependency details.
+ * @throws Error If the build process fails for any reason.
+ */
+export declare function analyzeDependencies(entryPoint: EntryPoints, platform?: BuildOptions['platform']): Promise<BuildResult & {
+    metafile: Metafile;
+}>;
+/**
+ * The `collectFunctionNames` function analyzes the provided TypeScript code and collects the names of functions
+ * that should be removed based on specific conditions. The function searches for function declarations and variable
+ * declarations where the function name or variable is prefixed with `$$`, and adds these function names to the
+ * `removeFunctions` set in the provided `state` object.
+ *
+ * - **Input**:
+ *   - `code`: A string containing the TypeScript code to be analyzed.
+ *   - `state`: An object representing the current build state, specifically the `mocks` state, which includes
+ *     a `removeFunctions` set that will hold the names of functions that need to be removed.
+ *
+ * - **Output**: The function does not return any value. Instead, it modifies the `removeFunctions` set inside the
+ *   `state` object by adding function names that meet the criteria for removal.
+ *
+ * ## Error Handling:
+ * - The function does not explicitly handle errors. If invalid TypeScript code is provided, `ts.createSourceFile`
+ *   may throw an error, which should be handled by the caller if necessary.
+ *
+ * @param code - The TypeScript code as a string that will be analyzed.
+ * @param state - The build state containing the `removeFunctions` set to store the names of functions to be removed.
+ * @returns `void` - The function modifies the `state` directly and does not return a value.
+ */
+export declare function collectFunctionNames(code: string, state: BuildStateInterface['macros']): void;
+/**
+ * The `collectDeclaredFunctions` function processes the provided `meta` metafile and reads each file's contents
+ * to find function declarations within preprocessor directives. It uses regular expressions to match `// ifdef` and
+ * `// endif` blocks in the code and collects the function names from the code inside the `ifdef` block, based on the
+ * `define` configuration in the `config` object. If the condition defined in the `ifdef` is not met (i.e., not defined
+ * in the `config.define`), the function names found inside the block will be collected and added to the `removeFunctions`
+ * set in the `state` object.
+ *
+ * - **Input**:
+ *   - `meta`: The `Metafile` object that contains the input files. The keys are file paths, and the values contain
+ *     metadata about those files.
+ *   - `config`: The configuration object containing a `define` field, which is an object of conditions that may be used
+ *     in the `ifdef` blocks. If a condition in an `ifdef` block is not defined in `config.define`, the functions in
+ *     that block will be collected.
+ *   - `state`: The build state, specifically the `mocks` state, which includes a `removeFunctions` set that stores
+ *     function names to be removed.
+ *
+ * - **Output**: This function does not return a value. It modifies the `removeFunctions` set within the provided `state`
+ *   object by adding the names of functions found inside unprocessed `ifdef` blocks.
+ *
+ * ## Error Handling:
+ * - If a file cannot be read due to a filesystem error, the function will throw an error.
+ * - If the provided `meta` or `config` is malformed, it may result in runtime errors. The caller should ensure valid input.
+ *
+ * @param meta - The `Metafile` object containing the list of input files and their metadata.
+ * @param config - The configuration object that defines conditions used in `ifdef` blocks.
+ * @param state - The build state containing the `removeFunctions` set to store function names to be removed.
+ * @returns `void` - The function modifies the `state` directly and does not return a value.
+ */
+export declare function collectDeclaredFunctions(meta: Metafile, config: ConfigurationInterface, state: BuildStateInterface['macros']): Promise<void>;
+/**
+ * The `parseMacros` function processes TypeScript or JavaScript files to transform macros defined within the content.
+ * It ensures that the build state is initialized if necessary, analyzes file dependencies, collects declared functions
+ * that are marked for removal, and applies transformations to the source code based on the macros.
+ * If the file's extension is not `.ts` or `.js`, the function returns `undefined`. Otherwise, it transforms the code
+ * and returns the result in the specified loader format.
+ *
+ * - **Input**:
+ *   - `content`: The content of the file as a string or `Uint8Array` to be parsed.
+ *   - `loader`: A string representing the loader type for transforming the code (e.g., `'ts'`, `'js'`).
+ *   - `args`: The `OnLoadArgs` object containing metadata for the current loading process, including the file path.
+ *   - `state`: The build state containing the `mocks` object, which includes a `removeFunctions` set that tracks
+ *     functions to be removed.
+ *   - `config`: The configuration object that defines how macros should be handled (e.g., conditions for macro processing).
+ *
+ * - **Output**: A `Promise` that resolves to an `OnLoadResult`, `pluginResultType`, or `undefined`. If the file is
+ *   of type `.ts` or `.js`, the transformed code is returned in the specified loader format (e.g., `'ts'`). If the file
+ *   extension is not recognized, the function returns `undefined`.
+ *
+ * ## Error Handling:
+ * - If the file path does not end with `.ts` or `.js`, the function returns `undefined`.
+ * - If `state.mocks` is not initialized, it will be set up by analyzing the file dependencies and collecting declared functions.
+ * - If any errors occur during the analysis, function collection, or transformation, the function may throw an error.
+ *
+ * @param content - The content of the file as a string or `Uint8Array` to be parsed.
+ * @param loader - The loader type for transforming the code (e.g., `'ts'` or `'js'`).
+ * @param args - The `OnLoadArgs` containing metadata, including the file path.
+ * @param state - The build state that includes `mocks` with the `removeFunctions` set.
+ * @param config - The configuration object defining how macros should be handled.
+ * @returns A `Promise` that resolves to the transformed code (`OnLoadResult` or `pluginResultType`), or `undefined`
+ *          if the file is not of type `.ts` or `.js`.
+ */
+export declare function parseMacros(content: string | Uint8Array, loader: Loader | undefined, args: OnLoadArgs, state: BuildStateInterface, config: ConfigurationInterface): Promise<OnLoadResult | pluginResultType | undefined>;
+/**
+ * Represents an error that occurs during the esbuild process.
+ *
+ * This class extends the base error class to provide specific error handling for esbuild-related issues.
+ * It captures the error message and maintains the proper stack trace, allowing for easier debugging
+ * and identification of errors that occur during the build process.
+ *
+ * @class esBuildError
+ * @extends BaseError
+ */
+export declare class esBuildError extends BaseError {
+    originalErrorStack?: string;
+    /**
+     * Creates an instance of the EsbuildError class.
+     *
+     * @param message - An object containing the error message. The `text` property is used to initialize
+     * the base error class with a descriptive message about the error encountered during the esbuild process.
+     */
+    constructor(message: Message);
+    /**
+     * Generates a formatted error message with highlighted code.
+     *
+     * @param message - An esbuild Message object containing error information.
+     * @returns A formatted string of the error message.
+     */
+    private generateFormattedError;
+    /**
+     * Reads code from a file if it exists.
+     *
+     * @param path - The file path to read from.
+     * @returns Array of lines if file exists, otherwise null.
+     */
+    private readCode;
+    /**
+     * Formats a code snippet with highlighted errors.
+     *
+     * @param code - Array of code lines.
+     * @param location - The error location within the file.
+     * @returns A formatted and highlighted code snippet string.
+     */
+    private formatCodeSnippet;
+    /**
+     * Applies color to a given text if colors are enabled.
+     *
+     * @param color - The color code.
+     * @param text - The text to colorize.
+     * @returns The colorized text if colors are active, otherwise plain text.
+     */
+    private applyColor;
+}
+/**
+ * ASCII Logo and Version Information
+ *
+ * @remarks
+ * The `asciiLogo` constant stores an ASCII representation of the project logo
+ * that will be displayed in the banner. This banner is rendered in a formatted
+ * string in the `bannerComponent` function.
+ *
+ * The `cleanScreen` constant contains an ANSI escape code to clear the terminal screen.
+ */
+export declare const asciiLogo = "\n     ______       _ _     _\n     | ___ \\     (_) |   | |\n__  _| |_/ /_   _ _| | __| |\n\\ \\/ / ___ \\ | | | | |/ _` |\n >  <| |_/ / |_| | | | (_| |\n/_/\\_\\____/ \\__,_|_|_|\\__,_|\n";
+export declare const cleanScreen = "\u001Bc";
+/**
+ * Renders the banner with the ASCII logo and version information.
+ *
+ * This function constructs and returns a formatted banner string that includes an ASCII logo and the version number.
+ * The colors used for the ASCII logo and version number can be enabled or disabled based on the `activeColor` parameter.
+ * If color formatting is enabled, the ASCII logo will be rendered in burnt orange, and the version number will be in bright pink.
+ *
+ * @param activeColor - A boolean flag indicating whether ANSI color formatting should be applied. Default is `__ACTIVE_COLOR`.
+ *
+ * @returns A formatted string containing the ASCII logo, version number, and ANSI color codes if `activeColor` is `true`.
+ *
+ * @remarks
+ * The `bannerComponent` function clears the terminal screen, applies color formatting if enabled, and displays
+ * the ASCII logo and version number. The version number is retrieved from the global `__VERSION` variable, and
+ * the colors are reset after the text is rendered.
+ *
+ * @example
+ * ```ts
+ * console.log(bannerComponent());
+ * ```
+ *
+ * This will output the banner to the console with the ASCII logo, version, and colors.
+ *
+ * @example
+ * ```ts
+ * console.log(bannerComponent(false));
+ * ```
+ *
+ * This will output the banner to the console with the ASCII logo and version number without color formatting.
+ *
+ * @public
+ */
+export declare function bannerComponent(activeColor?: boolean): string;
+/**
+ * A formatted string prefix used for logging build-related messages.
+ * // todo optimize this
+ */
+export declare function prefix(): string;
+/**
+ * Manages the HTTP or HTTPS server based on the provided configuration.
+ *
+ * The `ServerProvider` class initializes and starts either an HTTP or HTTPS server based on whether SSL certificates
+ * are provided. It handles incoming requests, serves static files, and lists directory contents with appropriate
+ * icons and colors.
+ *
+ * @class
+ */
+export declare class ServerProvider {
+    /**
+     * Root dir to serve
+     */
+    private readonly rootDir;
+    /**
+     * Indicates whether the server is configured to use HTTPS.
+     */
+    private readonly isHttps;
+    /**
+     * The server configuration object, including SSL certificate paths and other settings.
+     */
+    private readonly config;
+    /**
+     * Creates an instance of ServerProvider.
+     *
+     * @param config - The server configuration object, including port number, SSL certificate paths, and an optional request handler.
+     * @param dir - The root directory from which to serve files.
+     *
+     * @example
+     * ```ts
+     * import { ServerProvider } from './server-provider';
+     *
+     * const serverConfig = {
+     *     port: 8080,
+     *     keyfile: './path/to/keyfile',
+     *     certfile: './path/to/certfile',
+     *     onRequest: (req, res, next) => { /* custom request handling *\/ }
+     * };
+     * const provider = new ServerProvider(serverConfig, './public');
+     * provider.start();
+     * ```
+     *
+     * This example shows how to create an instance of `ServerProvider` and start the server.
+     */
+    constructor(config: Serve, dir: string);
+    /**
+     * Starts the server based on the configuration.
+     * If SSL certificates are provided and valid, an HTTPS server is started. Otherwise, an HTTP server is started.
+     *
+     * @example
+     * ```ts
+     * provider.start();
+     * ```
+     *
+     * This example demonstrates how to start the server. It will either start an HTTP or HTTPS server based on the configuration.
+     */
+    start(): void;
+    /**
+     * Starts an HTTP server.
+     * This method creates an HTTP server that listens on the configured port and handles incoming requests.
+     *
+     * @example
+     * ```ts
+     * provider.startHttpServer();
+     * ```
+     *
+     * This example shows how the `startHttpServer` method is used internally to start an HTTP server.
+     */
+    private startHttpServer;
+    /**
+     * Starts an HTTPS server.
+     *
+     * This method creates an HTTPS server with SSL/TLS certificates, listens on the configured port, and handles incoming requests.
+     *
+     * @example
+     * ```ts
+     * provider.startHttpsServer();
+     * ```
+     *
+     * This example shows how the `startHttpsServer` method is used internally to start an HTTPS server.
+     */
+    private startHttpsServer;
+    /**
+     * Handles incoming requests.
+     *
+     * This method checks if a custom request handler is provided in the configuration. If so, it uses the custom handler.
+     * Otherwise, it delegates to the default request handler.
+     *
+     * @param req - The incoming request object.
+     * @param res - The response object.
+     * @param defaultHandler - The default handler functions to be called if no custom handler is provided.
+     *
+     * @example
+     * ```ts
+     * // This method is used internally to handle requests
+     * ```
+     */
+    private handleRequest;
+    /**
+     * Returns the MIME type for a given file extension.
+     *
+     * This method maps file extensions to their corresponding MIME types.
+     *
+     * @param ext - The file extension.
+     * @returns The MIME type associated with the file extension.
+     *
+     * @example
+     * ```ts
+     * const mimeType = provider.getContentType('html');
+     * console.log(mimeType); // 'text/html'
+     * ```
+     */
+    private getContentType;
+    /**
+     * Handles the default response for requests, serving files or directories.
+     *
+     * This method serves the content of files or directories. If the request is for a directory, it lists the contents with
+     * appropriate icons and colors.
+     *
+     * @param req - The incoming request object.
+     * @param res - The response object.
+     *
+     * @returns A promise that resolves when the response is sent.
+     *
+     * @throws  Throws an error if the file or directory cannot be accessed.
+     *
+     * @example
+     * ```ts
+     * // This method is used internally to handle file and directory responses
+     * ```
+     */
+    private defaultResponse;
+    /**
+     * promisifyStat the `fs.stat` method.
+     *
+     * Converts the `fs.stat` callback-based method to return a promise.
+     *
+     * @param path - The file or directory path.
+     * @returns A promise that resolves with the file statistics.
+     *
+     * @example
+     * ```ts
+     * const stats = await provider.promisifyStat('./path/to/file');
+     * console.log(stats.isFile()); // true or false
+     * ```
+     */
+    private promisifyStat;
+    /**
+     * Handles directory listings.
+     *
+     * Reads the contents of a directory and generates an HTML response with file icons and colors.
+     *
+     * @param fullPath - The full path to the directory.
+     * @param requestPath - The request path for generating relative links.
+     * @param res - The response object.
+     *
+     * @example
+     * ```ts
+     * // This method is used internally to handle directory listings
+     * ```
+     */
+    private handleDirectory;
+    /**
+     * Handles file responses.
+     *
+     * Reads and serves the content of a file.
+     *
+     * @param fullPath - The full path to the file.
+     * @param res - The response object.
+     *
+     * @example
+     * ```ts
+     * // This method is used internally to handle file responses
+     * ```
+     */
+    private handleFile;
+    /**
+     * Sends a 404 Not Found response.
+     *
+     * @param res - The response object.
+     *
+     * @example
+     * ```ts
+     * provider.sendNotFound(response);
+     * ```
+     *
+     * This example demonstrates how to send a 404 response using the `sendNotFound` method.
+     */
+    private sendNotFound;
+    /**
+     * Sends an error response.
+     *
+     * @param res - The response object.
+     * @param error - The error object.
+     *
+     * @example
+     * ```ts
+     * provider.sendError(response, new Error('Some error'));
+     * ```
+     *
+     * This example shows how to send an error response using the `sendError` method.
+     */
+    private sendError;
+}
+/**
+ * Plugin provider for esbuild that registers hooks for lifecycle events such as onStart, onEnd, onResolve, and onLoad.
+ * This class allows dynamic behavior by registering multiple hooks for different stages of the build process.
+ */
+export declare class PluginsProvider {
+    /**
+     * Holds the build state that hooks can modify.
+     */
+    private buildState;
+    /**
+     * Holds the registered hooks for the `onEnd` lifecycle event.
+     * This array contains functions that are called after the build process completes.
+     */
+    private onEndHooks;
+    /**
+     * Holds the registered hooks for the `onSuccess` lifecycle event.
+     * This array contains functions that are called after the build success finish.
+     */
+    private onSuccess;
+    /**
+     * Holds the registered hooks for the `onLoad` lifecycle event.
+     * This array contains functions that are called when esbuild attempts to load a module.
+     */
+    private onLoadHooks;
+    /**
+     * Holds the registered hooks for the `onStart` lifecycle event.
+     * This array contains functions that are called before the build process starts.
+     */
+    private onStartHooks;
+    /**
+     * Holds the registered hooks for the `onResolve` lifecycle event.
+     * This array contains functions that are called when esbuild attempts to resolve a module path.
+     */
+    private onResolveHooks;
+    /**
+     * Registers a hook function for the `onStart` lifecycle event.
+     * The hook will be called before the build process starts.
+     *
+     * @param fn - A function of type `OnStartType` that will be executed when the build process starts.
+     *
+     * @example
+     * ```ts
+     * pluginProvider.registerOnStart(async (build) => {
+     *   console.log('Build started:', build);
+     * });
+     * ```
+     */
+    registerOnStart(fn: OnStartType | undefined): void;
+    /**
+     * Registers a hook function for the `onEnd` lifecycle event.
+     * The hook will be called after the build process completes.
+     *
+     * @param fn - A function of type `OnEndType` that will be executed after the build completes.
+     *
+     * @example
+     * ```ts
+     * pluginProvider.registerOnEnd(async (result) => {
+     *   console.log('Build finished:', result);
+     * });
+     * ```
+     */
+    registerOnEnd(fn: OnEndType | undefined): void;
+    /**
+     * Registers a hook function for the `onSuccess` lifecycle event.
+     * The hook will be called after the build success completes.
+     *
+     * @param fn - A function of type `OnEndType` that will be executed after the build completes.
+     *
+     * @example
+     * ```ts
+     * pluginProvider.registerOnSuccess(async (result) => {
+     *   console.log('Build Success finished:', result);
+     * });
+     * ```
+     */
+    registerOnSuccess(fn: OnEndType | undefined): void;
+    /**
+     * Registers a hook function for the `onResolve` lifecycle event.
+     * The hook will be called when esbuild attempts to resolve a module path.
+     *
+     * @param fn - A function of type `OnResolveType` that will be executed during module resolution.
+     *
+     * @example
+     * ```ts
+     * pluginProvider.registerOnResolve(async (args) => {
+     *   if (args.path === 'my-module') {
+     *     return { path: './src/my-module.ts' };
+     *   }
+     *   return null;
+     * });
+     * ```
+     */
+    registerOnResolve(fn: OnResolveType | undefined): void;
+    /**
+     * Registers a hook function for the `onLoad` lifecycle event.
+     * The hook will be called when esbuild attempts to load a module.
+     *
+     * @param fn - A function of type `OnLoadType` that will be executed during module loading.
+     *
+     * @example
+     * ```ts
+     * pluginProvider.registerOnLoad(async (contents, loader, args) => {
+     *   if (args.path.endsWith('.json')) {
+     *     return { contents: JSON.stringify({ key: 'value' }), loader: 'json' };
+     *   }
+     *   return null;
+     * });
+     * ```
+     */
+    registerOnLoad(fn: OnLoadType | undefined): void;
+    /**
+     * Registers esbuild plugin hooks and sets up the middleware plugin.
+     *
+     * This function defines the setup for an esbuild plugin, enabling hooks for various lifecycle events:
+     * onStart, onEnd, onResolve, and onLoad. It ensures that hooks registered by the user are called at
+     * the appropriate stages of the build process.
+     *
+     * @returns An object with the plugin configuration that can be passed to esbuild's `plugins` array.
+     * The configuration includes the plugin name and setup function.
+     *
+     * @example
+     * ```ts
+     * // Example usage with esbuild:
+     * const esbuild = require('esbuild');
+     * const pluginProvider = new PluginsProvider();
+     *
+     * esbuild.build({
+     *   entryPoints: ['./src/index.ts'],
+     *   bundle: true,
+     *   plugins: [pluginProvider.setup()],
+     * }).catch(() => process.exit(1));
+     * ```
+     */
+    setup(): {
+        name: string;
+        setup: (build: PluginBuild) => void;
+    };
+    /**
+     * Executes all registered onStart hooks.
+     *
+     * This function is called when the build process starts and invokes each hook registered via
+     * `registerOnStart`. Hooks can perform actions such as initializing tasks, logging, or setting
+     * up build conditions.
+     *
+     * @param build - The esbuild `PluginBuild` object that represents the current build process.
+     *
+     * @returns A promise that resolves when all hooks have been executed.
+     *
+     * @example
+     * ```ts
+     * // Registering an onStart hook
+     * pluginProvider.registerOnStart(async (build) => {
+     *   console.log('Build started:', build);
+     * });
+     * ```
+     */
+    private handleOnStart;
+    /**
+     * Executes all registered onEnd hooks after the build finishes.
+     *
+     * This function is called after the build process completes and invokes each hook registered via
+     * `registerOnEnd`. Hooks can be used to process the build results, such as performing analysis or cleanup.
+     *
+     * @param buildResult - The build buildResult object provided by esbuild, containing details about the build process.
+     *
+     * @returns A promise that resolves when all hooks have been executed.
+     *
+     * @example
+     * ```ts
+     * // Registering an onEnd hook
+     * pluginProvider.registerOnEnd(async (buildResult) => {
+     *   console.log('Build completed:', buildResult);
+     * });
+     * ```
+     */
+    private handleOnEnd;
+    /**
+     * Resolves module imports using registered onResolve hooks.
+     *
+     * This function is called whenever esbuild attempts to resolve a module path. It iterates over all registered
+     * onResolve hooks and merges their results. If no hook resolves a path, `null` is returned.
+     *
+     * @param args - The esbuild `OnResolveArgs` object containing information about the module being resolved.
+     *
+     * @returns A promise that resolves to an `OnResolveResult` containing the resolved path, or `null` if no path is found.
+     *
+     * @example
+     * ```ts
+     * // Registering an onResolve hook
+     * pluginProvider.registerOnResolve(async (args) => {
+     *   if (args.path === 'my-module') {
+     *     return { path: './src/my-module.ts' };
+     *   }
+     *   return null;
+     * });
+     * ```
+     */
+    private handleOnResolve;
+    /**
+     * Loads module contents using registered onLoad hooks.
+     *
+     * This function is called when esbuild attempts to load a module. It reads the module contents and then
+     * processes it through all registered onLoad hooks. The hooks can modify the contents and loader type.
+     *
+     * @param args - The esbuild `OnLoadArgs` object containing information about the module being loaded.
+     *
+     * @returns A promise that resolves to an `OnLoadResult` containing the module contents and loader, or `null` if no contents are loaded.
+     *
+     * @example
+     * ```ts
+     * // Registering an onLoad hook
+     * pluginProvider.registerOnLoad(async (contents, loader, args) => {
+     *   if (args.path.endsWith('.json')) {
+     *     return { contents: JSON.stringify({ key: 'value' }), loader: 'json' };
+     *   }
+     *   return null;
+     * });
+     * ```
+     */
+    private handleOnLoad;
+}
+/**
+ * Parses and filters content based on conditional directives.
+ *
+ * This function processes the given code contents and removes sections that
+ * are conditionally compiled based on the provided `defines` object.
+ *
+ * @param contents - The code contents to be processed.
+ * @param defines - An object containing conditional
+ *   definitions. Keys are condition names, and values are their definitions.
+ * @returns The processed code contents with conditional blocks removed
+ *   according to the `defines` object.
+ */
+export declare function parseIfDefConditionals(contents: string, defines: Record<string, unknown>): string;
+/**
+ * Resolves path aliases in the provided content based on the specified paths and root directory.
+ *
+ * This function takes a string of content and replaces occurrences of defined path alias keys
+ * with their corresponding relative paths derived from the specified source file and root directory.
+ * It ensures that the resulting paths are relative to the directory of the source file and formatted
+ * correctly for use in a JavaScript/TypeScript environment.
+ *
+ * Example:
+ * Given the following inputs:
+ * ```ts
+ * const content = "import { foo } from '@core/foo';";
+ * const sourceFile = "/project/src/index.ts";
+ * const paths = {
+ *   '@core/': 'src/core',
+ *   '@utils/': 'src/utils'
+ * };
+ * const rootDir = "/project";
+ * ```
+ * The function will replace `@core/foo` with a relative path based on the source file's location,
+ * potentially resulting in:
+ * ```ts
+ * const content = "import { foo } from './core/foo';";
+ * ```
+ *
+ * @param content - The content in which path aliases need to be resolved.
+ * @param sourceFile - The path of the source file from which relative paths will be calculated.
+ * @param paths - An object mapping path alias keys to their corresponding paths.
+ * @param esm -  A flag indicating whether ESM is enabled.
+ * @returns The updated content with resolved path aliases.
+ */
+export declare function resolveAliasPlugin(content: string, sourceFile: string, paths: Record<string, string>, esm: boolean): string;
+/**
+ * Represents TypeScript node types that can have modifiers applied to them.
+ * This union type includes all declaration types that support TypeScript modifiers
+ * like export, default, abstract, public, private, etc.
+ *
+ * @see ts.ClassDeclaration
+ * @see ts.InterfaceDeclaration
+ * @see ts.EnumDeclaration
+ * @see ts.FunctionDeclaration
+ * @see ts.TypeAliasDeclaration
+ * @see ts.VariableStatement
+ * @see ts.ModuleDeclaration
+ *
+ * @since 1.5.5
+ */
+export type NodeWithModifiersType = ts.ClassDeclaration | ts.InterfaceDeclaration | ts.EnumDeclaration | ts.FunctionDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement | ts.ModuleDeclaration;
+/**
+ * Custom error class to represent type-related errors.
+ *
+ * This class extends the built-in `Error` class to provide more specific
+ * error handling for issues related to types. It can be used to distinguish
+ * errors that occur due to type mismatches or other type-related problems
+ * in your application.
+ *
+ * @example
+ * ```ts
+ * throw new TypesError('Invalid type encountered.');
+ * ```
+ *
+ * @augments Error
+ */
+export declare class TypesError extends Error {
+    /**
+     * Creates an instance of `TypesError`.
+     *
+     * @param message - A human-readable message providing details about the error.
+     * @param options - Optional configuration for the error, such as a `cause` (ECMAScript 2022+).
+     */
+    constructor(message?: string, options?: {
+        cause?: Error;
+    });
+}
+/**
+ * Provides TypeScript-related utilities such as type-checking, generating declaration files,
+ * and transforming module specifiers into relative paths based on the output directory.
+ *
+ * The `TypescriptProvider` class enables users to type-check TypeScript projects, generate
+ * declaration files, and transform import/export paths into relative paths that match the output directory.
+ * It uses the TypeScript Compiler API to achieve these transformations.
+ *
+ * @class
+ * @example
+ * ```ts
+ * const tsProvider = new TypescriptProvider(parsedConfig, './dist');
+ * tsProvider.typeCheck(entryPoints);
+ * tsProvider.generateDeclarations(entryPoints);
+ * ```
+ */
+export declare class TypeScriptProvider {
+    tsConfig: ts.ParsedCommandLine;
+    private outDir;
+    private activeColor;
+    /**
+     * Compiler options for configuring TypeScript compilation.
+     */
+    readonly options: ts.CompilerOptions;
+    /**
+     * Creates an instance of `TypescriptProvider` with the given TypeScript configuration and output directory.
+     *
+     * This constructor initializes a `TypescriptProvider` with the provided TypeScript configuration
+     * and the directory where output files (such as declaration files) will be stored.
+     * Additionally, it accepts a flag to control whether ANSI color formatting should be applied in output messages.
+     *
+     * @param tsConfig - The parsed TypeScript configuration object.
+     * @param outDir - The directory where output files (such as declaration files) will be stored.
+     * @param activeColor - A boolean flag indicating whether ANSI color formatting should be applied in output messages.
+     * Default is `true`.
+     *
+     * @example
+     * ```ts
+     * const tsProvider = new TypescriptProvider(parsedConfig, './dist');
+     * ```
+     *
+     * @example
+     * ```ts
+     * const tsProvider = new TypescriptProvider(parsedConfig, './dist', false);
+     * // This instance will not apply ANSI color formatting in output messages
+     * ```
+     */
+    constructor(tsConfig: ts.ParsedCommandLine, outDir: string, activeColor?: boolean);
+    /**
+     * Performs type-checking on the specified entry points without emitting any files.
+     *
+     * This method compiles the provided TypeScript files to check for type errors and other diagnostics without
+     * generating any output files. It ensures that the code adheres to TypeScript's type constraints and reports
+     * any issues found during the type-checking process.
+     *
+     * @param allowError - A boolean flag indicating whether to throw an error if diagnostics are present. If set to
+     * `true`, errors are logged but not thrown, allowing the process to continue. Default to `false`, which throws
+     * an error if diagnostics are encountered.
+     *
+     * @returns void
+     *
+     * @throws Throws an error if type-checking fails due to TypeScript diagnostics and `allowError` is `false`.
+     * The error indicates that the type-checking process has encountered issues.
+     *
+     * @example
+     * ```ts
+     * // Type-check files and handle any diagnostics
+     * tsProvider.typeCheck(['src/index.ts', 'src/app.ts']);
+     * ```
+     */
+    typeCheck(allowError?: boolean): void;
+    /**
+     * Generates declaration files (.d.ts) for bundle entry points.
+     *
+     * @param entryPoints - Map of output declaration file paths to their corresponding input source files
+     * @param noTypeChecker - When true, skips type checking during generation (default: false)
+     * @param allowError - When true, continues generation even if type errors are found (default: false)
+     *
+     * @throws Error - If type errors are found and allowError is false
+     *
+     * @remarks
+     * This method creates TypeScript declaration files for each entry point specified in the record.
+     * For each entry point:
+     *
+     * 1. Create a TypeScript program with input file
+     * 2. Configure the program to emit declaration files only
+     * 3. Applies custom transformers to clean up declarations
+     * 4. Performs type checking (unless disabled)
+     * 5. Emits the declaration file to the specified output path
+     *
+     * The generated declarations are processed by the cleanupDeclarations transformer,
+     * which removes export modifiers and performs another necessary cleanup.
+     *
+     * Type errors will normally cause the process to fail unless allowError is set to true.
+     *
+     * @example
+     * ```ts
+     * // Generate declarations for multiple entry points
+     * generator.generateBundleDeclarations({
+     *   './dist/index.d.ts': './src/index.ts',
+     *   './dist/core.d.ts': './src/core.ts'
+     * });
+     * ```
+     *
+     * @since 1.5.5
+     */
+    generateBundleDeclarations(entryPoints: Record<string, string>, noTypeChecker?: boolean, allowError?: boolean): void;
+    /**
+     * Generates TypeScript declaration files (`.d.ts`) for the specified entry points.
+     *
+     * This method compiles the provided TypeScript files and emits only the declaration files, without generating
+     * JavaScript code. It applies a custom transformer to modify module specifiers to relative paths based on the
+     * output directory. This ensures that the generated declaration files are accurate and the module paths are
+     * aligned with the project's build structure.
+     *
+     * @param entryPoints - Map of output declaration file paths to their corresponding input source files
+     * @param noTypeChecker - Skips TypeScript type checking.
+     * @param allowError - A boolean flag indicating whether to throw an error if diagnostics are present. If set to
+     * `true`, errors are logged but not thrown, allowing the process to continue. Default to `false`, which throws
+     * an error if diagnostics are encountered.
+     *
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // Generate declaration files for specific entry points
+     * tsProvider.generateDeclarations(['src/index.ts', 'src/app.ts']);
+     * ```
+     */
+    generateDeclarations(entryPoints: Record<string, string>, noTypeChecker?: boolean, allowError?: boolean): void;
+    /**
+     * Checks if the provided node is an import or export declaration.
+     *
+     * @param node - A TypeScript AST node to check.
+     *
+     * @returns `true` if the node is either an `ImportDeclaration` or `ExportDeclaration`; otherwise, `false`.
+     *
+     * @example
+     * ```ts
+     * const isDeclaration = tsProvider.isImportOrExportDeclaration(node);
+     * console.log(isDeclaration); // true or false
+     * ```
+     */
+    private isImportOrExportDeclaration;
+    /**
+     * Checks if the provided node has a string literal as its module specifier.
+     *
+     * @param node - A TypeScript AST node to check.
+     *
+     * @returns `true` if the node has a string literal module specifier; otherwise, `undefined`.
+     *
+     * @example
+     * ```ts
+     * const hasModuleSpecifier = tsProvider.hasStringLiteralModuleSpecifier(importNode);
+     * console.log(hasModuleSpecifier); // true or undefined
+     * ```
+     */
+    private hasStringLiteralModuleSpecifier;
+    /**
+     * Resolves the module file name based on the module specifier and TypeScript compiler options.
+     *
+     * @param specifierText - The module specifier text (e.g., `'./module'`).
+     * @param options - The TypeScript compiler options.
+     *
+     * @returns The resolved file path of the module or `undefined` if the module cannot be resolved.
+     *
+     * @example
+     * ```ts
+     * const resolvedPath = tsProvider.resolveModuleFileName('./module', compilerOptions);
+     * console.log(resolvedPath); // './dist/module.js'
+     * ```
+     */
+    private resolveModuleFileName;
+    /**
+     * Computes the relative path from the source file to the resolved target file.
+     *
+     * @param sourceFile - The absolute path of the source file.
+     * @param resolvedTargetFile - The absolute path of the resolved target file.
+     *
+     * @returns A relative path from the source file to the target file.
+     *
+     * @example
+     * ```ts
+     * const relativePath = tsProvider.getRelativePathToOutDir('./src/index.ts', './dist/module.js');
+     * console.log(relativePath); // './module.js'
+     * ```
+     */
+    private getRelativePathToOutDir;
+    /**
+     * Updates the module specifier of an import or export declaration to a relative path based on the output directory.
+     *
+     * This method takes a TypeScript `ImportDeclaration` or `ExportDeclaration` node and updates its module
+     * specifier to a relative path that matches the output directory. It uses the TypeScript compiler options
+     * to resolve the full path of the module and converts it into a relative path from the source file.
+     *
+     * This is useful when transforming module specifiers to ensure the generated declaration files (`.d.ts`)
+     * have correct paths when files are moved to the output directory.
+     *
+     * @param node - The TypeScript `ImportDeclaration` or `ExportDeclaration` node whose module specifier needs to be updated.
+     * @param sourceFile - The absolute path of the source file containing the node.
+     *
+     * @returns The updated `ImportDeclaration` or `ExportDeclaration` node with the new relative module specifier.
+     *
+     * @example
+     * ```ts
+     * const updatedNode = tsProvider.updateModuleSpecifier(importNode, './src/index.ts');
+     * console.log(updatedNode.moduleSpecifier.text); // './module.js'
+     * ```
+     */
+    private updateModuleSpecifier;
+    /**
+     * Creates a visitor function that transforms `ImportDeclaration` and `ExportDeclaration` nodes by updating
+     * their module specifiers to relative paths based on the output directory.
+     *
+     * This method returns a visitor function, which is used to traverse and transform the nodes in a TypeScript
+     * `SourceFile`. The visitor identifies `ImportDeclaration` and `ExportDeclaration` nodes with module specifiers
+     * that are string literals. For these nodes, the module specifiers are resolved to their corresponding file paths
+     * and updated to relative paths that align with the output directory.
+     *
+     * The visitor is designed to recursively visit all nodes in the `SourceFile`, transforming only the relevant
+     * import and export declarations while leaving other nodes unchanged.
+     *
+     * @param sourceFile - The TypeScript `SourceFile` that will be traversed by the visitor.
+     * @param context - The transformation context provided by the TypeScript compiler, used for visiting nodes.
+     *
+     * @returns A visitor function that processes the nodes in the source file, updating module specifiers as needed.
+     *
+     * @example
+     * ```ts
+     * const visitor = tsProvider.createVisitor(sourceFile, context);
+     * const transformedNode = visitor(importNode);
+     * console.log(transformedNode); // ImportDeclaration with updated module specifier
+     * ```
+     */
+    private createVisitor;
+    /**
+     * Creates a custom transformer factory for TypeScript that processes `SourceFile` nodes.
+     *
+     * This method returns a custom transformer factory function which generates a transformer that can be used
+     * during the TypeScript compilation process. The transformer specifically processes `SourceFile` nodes to
+     * apply custom transformations and does not alter `Bundle` nodes.
+     *
+     * The factory function generates a transformer that performs the following:
+     * - **Transforming `SourceFile` nodes**: Uses the `createVisitor` method to visit and transform all nodes in
+     *   a `SourceFile`. This allows custom modifications or analysis of TypeScript source files.
+     * - **No transformation for `Bundle` nodes**: The `transformBundle` method returns the bundle unchanged, as
+     *   no specific transformation is needed for bundles in this implementation.
+     *
+     * This transformer factory is used primarily for customizing TypeScript file transformations, such as updating
+     * module specifiers or other source-level adjustments during the compilation process.
+     *
+     * @returns A custom transformer factory function that produces a `CustomTransformer` object. This object
+     *          implements the `transformSourceFile` and `transformBundle` methods.
+     *
+     * @example
+     * ```ts
+     * const transformerFactory = tsProvider.createTransformerFactory();
+     * const emitResult = program.emit(undefined, undefined, undefined, true, {
+     *     after: [transformerFactory]
+     * });
+     * ```
+     */
+    private createTransformerFactory;
+    /**
+     * Handles and logs TypeScript diagnostics, providing detailed error messages with file and position information.
+     *
+     * This method processes an array of TypeScript diagnostics, printing formatted error messages to the console.
+     * If a diagnostic is associated with a specific file and position, the error message includes the filename,
+     * line, and character information. Colors are applied to highlight different parts of the message, such as
+     * file paths, positions, error messages, and error codes.
+     *
+     * If the `allowError` flag is `false`, the method throws an error when diagnostics are present, indicating
+     * that type checking has failed. If `allowError` is `true`, errors are logged but not thrown, allowing the process
+     * to continue despite the diagnostics.
+     *
+     * @param diagnostics - An array of readonly `Diagnostic` objects returned by the TypeScript compiler.
+     * These diagnostics contain information about errors or warnings that occurred during compilation.
+     *
+     * @param allowError - A boolean flag that determines whether the method should throw an error when diagnostics
+     * are encountered. If set to `true`, the method logs diagnostics but does not throw an error. Defaults to `false`.
+     *
+     * @throws Will throw an error if diagnostics are present and `allowError` is set to `false`. The error
+     * indicates that type checking has failed.
+     *
+     * @example
+     * ```ts
+     * const diagnostics = program.getSemanticDiagnostics();
+     * handleDiagnostics(diagnostics, false); // Throws an error if any diagnostics exist.
+     * ```
+     */
+    private handleDiagnostics;
+    /**
+     * Type guard to check if a node is one that can have modifiers.
+     *
+     * @param node - The TypeScript node to check
+     * @returns True if the node is a type that can have modifiers, false otherwise
+     *
+     * @remarks
+     * This type guard function identifies node types that can potentially have
+     * modifiers like 'export', 'default', etc. It's used in the AST transformation
+     * process to identify nodes where export modifiers need to be removed.
+     *
+     * The supported node types include:
+     * - Class declarations
+     * - Interface declarations
+     * - Enum declarations
+     * - Function declarations
+     * - Type alias declarations
+     * - Variable statements
+     * - Module declarations
+     *
+     * @see NodeWithModifiersType
+     * @see ts.Node
+     *
+     * @since 1.5.5
+     */
+    private isNodeWithModifiers;
+    /**
+     * Filters out export and default modifiers from an array of TypeScript modifiers.
+     *
+     * @param modifiers - Optional array of TypeScript modifiers to process
+     * @returns A new array without export/default modifiers, or undefined if no modifiers remain
+     *
+     * @remarks
+     * This helper method is used when transforming nodes to remove export-related functionality.
+     * It returns undefined instead of an empty array when no modifiers remain to ensure
+     * proper TypeScript AST structure.
+     *
+     * @example
+     * ```ts
+     * // Input: [export, const]
+     * // Output: [const]
+     *
+     * // Input: [export]
+     * // Output: undefined
+     * ```
+     *
+     * @see ts.Modifier
+     * @see ts.SyntaxKind.ExportKeyword
+     * @see ts.SyntaxKind.DefaultKeyword
+     *
+     * @since 1.5.5
+     */
+    private removeExportModifiers;
+    /**
+     * Updates a node by removing its export modifiers.
+     *
+     * @param node - A TypeScript node that can have modifiers
+     * @returns A new node with export and default modifiers removed
+     *
+     * @remarks
+     * This method dynamically determines the node type and applies the appropriate
+     * update function from the nodeUpdaters record.
+     *
+     * It works by:
+     * 1. First, removing export modifiers using removeExportModifiers method
+     * 2. Identifying the node type by matching it against TypeScript's type guards
+     * 3. Applying the corresponding updater function from nodeUpdaters
+     * 4. Falling back to returning the original node if no updater is found
+     *
+     * The dynamic approach avoids repetitive code for each node type while still
+     * maintaining type safety through TypeScript's built-in type guards.
+     *
+     * @see nodeUpdaters
+     * @see removeExportModifiers
+     * @see NodeWithModifiersType
+     *
+     * @since 1.5.5
+     */
+    private updateNodeWithoutExports;
+    /**
+     * Recursively visits and transforms nodes in the TypeScript AST.
+     *
+     * @param context - The transformation context provided by TypeScript
+     * @param node - The current node being visited
+     * @returns A transformed node with export modifiers removed where applicable
+     *
+     * @remarks
+     * This method is the core of the AST transformation process.
+     *
+     * It:
+     * 1. Checks if the current node is one that can have modifiers
+     * 2. If so, checks if it has any export or default modifiers
+     * 3. If export modifiers are found, remove them using updateNodeWithoutExports
+     * 4. Recursively visit all child nodes regardless of whether the current node was modified
+     *
+     * The recursion ensures that all nodes in the entire syntax tree are processed,
+     * resulting in a complete transformation that removes all export modifiers.
+     *
+     * @see isNodeWithModifiers
+     * @see updateNodeWithoutExports
+     * @see ts.visitEachChild
+     *
+     * @since 1.5.5
+     */
+    private visitNode;
+    /**
+     * Processes top-level TypeScript statements by handling imports, exports, and module declarations
+     * during transformation. This method filters internal imports, removes exports, and flattens module
+     * declarations to generate optimized output.
+     *
+     * @param node - The TypeScript statement being processed
+     * @param importMap - Collection of import clauses organized by module specifier
+     * @param sourceFiles - Array of internal source file paths that should be excluded
+     * @param context - TypeScript transformation context for node factory operations
+     * @returns Array of transformed statements or empty array if the statement is removed
+     *
+     * @throws TypesError - When encountering unsupported node types
+     *
+     * @remarks
+     * The transformation logic handles several specific cases:
+     * - Import declarations: Collects external imports and filters internal ones
+     * - Import equals declarations: Removes them from output
+     * - Export declarations: Removes them entirely
+     * - Module declarations: Unwraps content from declare modules, preserves others
+     *
+     * @example
+     * ```ts
+     * const result = this.visitTopLevelStatement(
+     *   sourceFile.statements[0],
+     *   new Map<string, Array<ts.ImportClause>>(),
+     *   ['./internal-module'],
+     *   transformContext
+     * );
+     * ```
+     *
+     * @see ts.Statement
+     * @see ts.ImportDeclaration
+     * @see ts.ModuleDeclaration
+     *
+     * @since 1.5.5
+     */
+    private visitTopLevelStatement;
+    /**
+     * Transforms a TypeScript source file by processing all its top-level statements and
+     * updating the source file with the processed statements while preserving metadata.
+     *
+     * @param sourceFile - The TypeScript source file to transform
+     * @param importMap - Collection mapping module specifiers to their import clauses
+     * @param sourceFiles - Array of source file paths used to identify internal modules
+     * @param context - The TypeScript transformation context
+     * @returns A new TypeScript source file with transformed statements
+     *
+     * @remarks
+     * This method flattens all source file statements by passing them through the
+     * visitTopLevelStatement processor, then creates an updated source file that
+     * preserves all original metadata including declaration status and references.
+     *
+     * @example
+     * ```ts
+     * const transformedFile = this.visitSourceFile(
+     *   program.getSourceFile("main.ts"),
+     *   new Map<string, Array<ts.ImportClause>>(),
+     *   ["./src/internal.ts"],
+     *   transformationContext
+     * );
+     * ```
+     *
+     * @throws TypesError - When transformation encounters incompatible node types
+     *
+     * @see ts.SourceFile
+     * @see ts.TransformationContext
+     *
+     * @since 1.5.5
+     */
+    private visitSourceFile;
+    /**
+     * Merges multiple TypeScript import clauses into a single consolidated import clause,
+     * handling default imports, named imports, and namespace imports.
+     *
+     * @param importClauses - Array of import clauses to merge
+     * @param isTypeOnly - Whether to force the resulting import to be type-only, defaults to true
+     * @returns A consolidated import clause or undefined if no import clauses provided
+     *
+     * @throws TypesError - When encountering incompatible import clause structures
+     *
+     * @remarks
+     * The merging process follows these rules:
+     * - Uses the first default import encountered
+     * - Collects all unique named imports across all clauses
+     * - Uses the first namespace import encountered
+     * - Handles type-only status according to the isTypeOnly parameter or source clauses
+     * - Returns undefined if the input array is empty
+     * - Returns the original clause if there's only one and not forcing type-only
+     *
+     * @example
+     * ```ts
+     * const imports = [
+     *   ts.factory.createImportClause(false, ts.factory.createIdentifier("default1"), undefined),
+     *   ts.factory.createImportClause(
+     *     false,
+     *     undefined,
+     *     ts.factory.createNamedImports([
+     *       ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("named1"))
+     *     ])
+     *   )
+     * ];
+     * const mergedImport = this.mergeImportClauses(imports, true);
+     * ```
+     *
+     * @see ts.ImportClause
+     * @see ts.NamedImports
+     * @see ts.NamespaceImport
+     *
+     * @since 1.5.6
+     */
+    private mergeImportClauses;
+    /**
+     * Creates a transformer factory that cleans up declarations in TypeScript bundles.
+     * This transformer extracts external imports from each source file in the bundle
+     * and consolidates them into a single imports file at the beginning of the bundle.
+     *
+     * @returns A transformer factory function that transforms TypeScript bundles
+     *
+     * @throws Error - When the input is not a bundle but a single source file
+     *
+     * @remarks
+     * The transformer processes each source file in the bundle, extracts external imports,
+     * and creates a new bundle with all imports consolidated at the beginning.
+     *
+     * @example
+     * ```ts
+     * const transformer = myClass.cleanupDeclarations();
+     * const result = ts.transform(bundle, [transformer]);
+     * ```
+     *
+     * @see ts.TransformerFactory
+     * @see ts.Bundle
+     *
+     * @since 1.5.5
+     */
+    private cleanupDeclarations;
+}
+/**
+ * The default configuration options for the build.
+ *
+ * @example
+ * ```ts
+ * import { defaultConfiguration } from '@configuration/default-configuration';
+ *
+ * console.log(defaultConfiguration);
+ * ```
+ *
+ * In this example, the `defaultConfiguration` is imported and logged to the console to view the default settings.
+ *
+ * @public
+ * @category Configuration
+ */
+export declare const defaultConfiguration: ConfigurationInterface;
+/**
+ * Executes JavaScript code within a sandboxed environment using Node.js's `vm` module.
+ *
+ * @param code - The JavaScript code to be executed within the sandbox.
+ * @param sandbox - An optional context object to be used as the global scope for the executed code.
+ *
+ * @returns The result of executing the provided code within the sandboxed environment.
+ *
+ * @remarks
+ * The `sandboxExecute` function creates a new `Script` instance with the provided code and
+ * runs it within a sandboxed context using the `createContext` function from the `vm` module.
+ * This approach ensures that the executed code is isolated from the rest of the application,
+ * mitigating potential security risks.
+ *
+ * The `sandbox` parameter allows you to provide a custom context or global object for the
+ * sandboxed code. If not provided, an empty context is used. The function also supports
+ * breaking execution on interrupt signals (e.g., Ctrl+C) with the `breakOnSigint` option.
+ *
+ * @throws Error Throws an error if the code cannot be compiled or executed within the context.
+ *
+ * @example
+ * ```ts
+ * const result = sandboxExecute('return 2 + 2;', { myGlobal: 10 });
+ * console.log(result); // Output: 4
+ * ```
+ *
+ * In this example, the `sandboxExecute` function runs a simple JavaScript expression and returns
+ * the result. The `sandbox` parameter is provided with an empty object in this case.
+ *
+ * @public
+ * @category Services
+ */
+export declare function sandboxExecute(code: string, sandbox?: Context): any;
+/**
+ * Parses a configuration file and returns a wrapped `ConfigurationInterface` object.
+ *
+ * This function reads the specified configuration file, transpiles it to a CommonJS format, and then executes it
+ * in a sandbox environment. The exported configuration object is wrapped so that any functions it contains will
+ * have sourcemap information attached to errors thrown during their execution.
+ *
+ * The wrapping of functions helps in debugging by associating errors with their source maps.
+ *
+ * @param file - The path to the configuration file that needs to be parsed and transpiled.
+ *
+ * @returns A promise that resolves to the parsed and transpiled `ConfigurationInterface` object.
+ * This object has its functions wrapped to attach sourcemap information to any errors thrown.
+ *
+ * @throws Will throw an error if the transpilation or execution of the configuration file fails.
+ * The thrown error will have sourcemap information attached if available.
+
+ * @example
+ * ```ts
+ * const config = await parseConfigurationFile('./config.jet.ts');
+ * console.log(config);
+ * ```
+ */
+export declare function parseConfigurationFile(file: string): Promise<ConfigurationInterface>;
+/**
+ * Reads and parses the TypeScript configuration file.
+ *
+ * @param options - A `BuildOptions` object that may contain a custom `tsconfig` path.
+ * @returns A `ParsedCommandLine` object representing the parsed TypeScript configuration.
+ * @throws xBuildError - Throws an error if the configuration file contains syntax errors.
+ */
+export declare function tsConfiguration(options: BuildOptions): ParsedCommandLine;
+/**
+ * Merges user configurations with CLI configurations and default settings
+ * to produce a final configuration object for the build process.
+ * This function handles both single and multiple user configurations,
+ * allowing for flexible configuration merging.
+ *
+ * @param userConfig - An array or a single object of type `PartialDeepConfigurationsType`
+ *                     representing the user's configurations to merge. If a single object
+ *                     is provided, it is wrapped in an array for processing.
+ * @param cliConfig - An optional object of type `PartialDeepConfigurationsType` representing
+ *                    the CLI configurations to merge with the user configurations. Defaults to an empty object.
+ * @returns An array of `ConfigurationInterface` objects, each representing a merged configuration.
+ *
+ * @throws xBuildError Throws an error if the `entryPoints` property in the merged configuration is undefined.
+ *                       This ensures that the configuration is valid and complete for further processing.
+ *
+ * @example
+ * ```ts
+ * import { configuration } from './configuration';
+ *
+ * const userConfigs = [
+ *     { esbuild: { entryPoints: ['src/index.ts'] } },
+ *     { serve: { port: 3000 } }
+ * ];
+ * const cliConfigs = { esbuild: { minify: true } };
+ *
+ * const finalConfigs = await configuration(userConfigs, cliConfigs);
+ * console.log('Merged Configuration:', finalConfigs);
+ * ```
+ */
+export declare function configuration(userConfig: Array<PartialDeepConfigurationsType> | PartialDeepConfigurationsType, cliConfig?: PartialDeepConfigurationsType): Promise<ConfigurationInterface[]>;
+/**
+ * Merges CLI arguments with a configuration file to produce a final configuration object.
+ * This function reads the specified configuration file and merges its contents with
+ * the CLI arguments provided. The resulting configuration will be validated to ensure
+ * that required properties, such as `entryPoints`, are defined.
+ *
+ * @param configFile - The path to the configuration file to read and merge with CLI arguments.
+ * @param cli - An instance of `Argv<ArgvInterface>` containing CLI arguments and options.
+ * @returns A promise that resolves to an array of `ConfigurationInterface` objects, representing
+ *          the final merged configuration.
+ * @throws Error Throws an error if the `entryPoints` property in the final configuration is undefined.
+ *                 This ensures that the configuration is valid for further processing.
+ *
+ * @example
+ * ```ts
+ * import { cliConfiguration } from './cli-configuration';
+ *
+ * const configFilePath = './config.json';
+ * const cliArgs = argv(); // Assuming `argv` is a function that retrieves CLI arguments
+ *
+ * cliConfiguration(configFilePath, cliArgs).then((finalConfig) => {
+ *     console.log('Final configuration: ', finalConfig);
+ * }).catch((error) => {
+ *     console.error('Error loading configuration:', error);
+ * });
+ * ```
+ */
+export declare function cliConfiguration(configFile: string, cli: Argv<ArgvInterface>): Promise<Array<ConfigurationInterface>>;
+/**
+ * Maps an array of file paths to an object where the keys are filenames (without extensions)
+ * and the values are the corresponding file paths.
+ *
+ * Each key in the resulting object is derived from the filename by removing the file extension.
+ * For example, given a file path `src/index.ts`, the key in the resulting object will be `src/index`.
+ *
+ * @param filePaths - An array of file paths to map. Each file path should be a string.
+ * @returns An object where the keys are filenames (without extensions) and the values are the corresponding file paths.
+ *
+ * @example
+ * ```ts
+ * const filePaths = ['src/index.ts', 'src/utils.ts'];
+ * const result = mapFilePathsToNames(filePaths);
+ * console.log(result);
+ * // Output: {
+ * //   'src/index': 'src/index.ts',
+ * //   'src/utils': 'src/utils.ts'
+ * // }
+ * ```
+ */
+export declare function mapFilePathsToNames(filePaths: Array<string>): Record<string, string>;
+/**
+ * Extracts and returns an object mapping output file paths to input file paths from the provided `EntryPoints` object.
+ *
+ * This function handles multiple formats of entry points, including:
+ * - An array of strings representing file paths.
+ * - An array of objects containing `in` and `out` properties, where `in` is the input file path and `out` is the output file path.
+ * - A `Record<string, string>` where the keys represent input file paths and the values represent output file paths.
+ *
+ * Depending on the format, the function constructs an object with the output file paths as keys and the input file paths as values.
+ * If the output path is not available, the filename (without extension) is used as the key.
+ *
+ * If a regular object with string keys and values (not in the supported formats) is provided, it will be returned as is.
+ *
+ * @param entryPoints - The entry points to extract from, which can be in different formats: an array of strings,
+ * an array of objects with `in` and `out` properties, or a `Record<string, string>`.
+ *
+ * @returns An object mapping output file paths to input file paths, or filename (without extension) to file path.
+ *
+ * @throws Will throw an `Error` if the entry points format is unsupported.
+ *
+ * @example
+ * ```ts
+ * const entryPoints = extractEntryPoints(['src/index.ts', 'src/utils.ts']);
+ * console.log(entryPoints); // { 'index': 'src/index.ts', 'utils': 'src/utils.ts' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const entryPoints = extractEntryPoints([{ in: 'src/index.ts', out: 'dist/index.js' }]);
+ * console.log(entryPoints); // { 'dist/index.js': 'src/index.ts' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const entryPoints = extractEntryPoints({ index: 'src/index.ts', index2: 'dist/index2.js' });
+ * console.log(entryPoints); // { index: 'src/index.ts', index2: 'dist/index2.js' }
+ * ```
+ */
+export declare function extractEntryPoints(entryPoints: EntryPoints): Record<string, string>;
+/**
+ * Generates a `package.json` file with the appropriate `type` field
+ * based on the format specified in the configuration.
+ *
+ * - If the format is `esm`, the `type` will be set to `"module"`.
+ * - If the format is `cjs`, the `type` will be set to `"commonjs"`.
+ *
+ * The function will ensure that the specified output directory exists, and if it doesn't,
+ * it will create the necessary directories before writing the `package.json` file.
+ *
+ * @param config - The build configuration object containing
+ * esbuild-related settings, such as the format (`format`).
+ *
+ * - `config.esbuild.format`: The module format, either `'esm'` or `'cjs'`, that determines the `type` field.
+ *
+ * @throws Will throw an error if there is a problem creating the directory or writing the file.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * const config = {
+ *   esbuild: {
+ *     format: 'esm'
+ *   }
+ * };
+ * packageTypeComponent(config);
+ * // This will create 'dist/package.json' with the content: {"type": "module"}
+ * ```
+ */
+export declare function packageTypeComponent(config: ConfigurationInterface): void;
+/**
+ * Manages the build process for a TypeScript project using esbuild.
+ *
+ * The `BuildService` class orchestrates the build process, including TypeScript compilation, handling of build errors,
+ * and lifecycle management of the build. It can operate in various modes, such as watching for file changes or running
+ * in development mode. It also provides functionality for spawning development processes and processing entry points.
+ *
+ * @remarks
+ * - The build process can be configured using the provided `ConfigurationInterface`.
+ * - Errors related to TypeScript are handled separately and are not logged by default.
+ * - The class supports various build modes, including watch mode and development mode, and handles different scenarios
+ *   based on the configuration.
+ *
+ * @public
+ * @category Services
+ */
+export declare class BuildService {
+    private config;
+    /**
+     * Provides TypeScript-related functionality for the build process.
+     */
+    readonly typeScriptProvider: TypeScriptProvider;
+    /**
+     * Keeps track of active development processes spawned during the build.
+     * This property holds an array of `ChildProcessWithoutNullStreams` instances that represent Node.js processes spawned
+     * for running development tasks. These processes are used to handle development builds or runtime tasks and are managed
+     * by the `BuildService` class to ensure they are properly started and stopped.
+     *
+     * @remarks
+     * - The array is populated when development processes are spawned, such as when specific development files are
+     *   processed or when running in development mode.
+     * - The processes are terminated gracefully at the end of the build to avoid leaving orphaned processes running.
+     * - It is important to manage these processes correctly to avoid resource leaks and ensure proper cleanup.
+     *
+     * @see ChildProcessWithoutNullStreams
+     */
+    private activePossess;
+    /**
+     * Plugin provider
+     *
+     * @private
+     */
+    private pluginsProvider;
+    /**
+     * Initializes the build service with the provided configuration.
+     *
+     * The constructor configures the TypeScript provider, suppresses esbuild logging,
+     * sets up development modes, and registers the necessary plugins.
+     *
+     * Declaration files will be output based on the following order of precedence:
+     * 1. If `declarationOutDir` is set in the configuration, it will be used.
+     * 2. If `declarationOutDir` is not provided, it will use the `outDir` value from the tsconfig.
+     * 3. If neither of the above is available, it falls back to using the `outdir` specified in the esbuild configuration.
+     *
+     * @param config - The configuration object for the build process, including esbuild and TypeScript settings.
+     */
+    constructor(config: ConfigurationInterface);
+    /**
+     * Executes the build process.
+     * This method performs the build and handles any errors that occur during the execution.
+     * If watching or development mode is enabled in the configuration, it starts watching for changes
+     * to automatically rebuild as needed.
+     * The method logs errors that are not related to TypeScript
+     * compilation issues.
+     *
+     * @returns A promise that resolves with a `BuildResult` when the build process is complete,
+     *          or `undefined` if an error occurs during execution.
+     *
+     * @throws Error Throws an error if the build process encounters issues that are not related
+     *                 to TypeScript. Such errors are logged, but the method does not rethrow them.
+     *
+     * @example
+     * ```ts
+     * import { BuildService } from './build-service';
+     *
+     * const buildService = new BuildService(config);
+     * buildService.run().then(() => {
+     *     console.log('Build process completed successfully.');
+     * }).catch((error) => {
+     *     console.error('Build process failed:', error);
+     * });
+     * ```
+     *
+     * In this example, the `run` method is invoked to execute the build process. It handles both successful
+     * completion and logs any encountered errors, allowing the user to understand the outcome of the build.
+     */
+    run(): Promise<BuildResult | void>;
+    /**
+     * Runs the build process in debug mode for the specified entry points.
+     * This method temporarily disables development and watch mode, initiates the build process, and spawns development processes
+     * for the specified entry points. If any errors occur during the build, they are handled appropriately.
+     *
+     * @param entryPoints - An array of entry point file names for which the development processes will be spawned.
+     * These entry points are matched against the build output files.
+     *
+     * @returns A `Promise<void>` that resolves when the build and process spawning have completed.
+     *
+     * @throws Handles any build-related errors using the `handleErrors` method.
+     *
+     * @remarks
+     * - The `config.dev` and `config.watch` settings are temporarily disabled to prevent development mode or file watching during the build.
+     * - The `build()` method is called to generate the necessary build outputs.
+     * - The `spawnDev` method is then invoked to spawn processes for the matching entry points.
+     * - If any errors occur during the build, they are caught and passed to the `handleErrors` method.
+     *
+     * @example
+     * ```ts
+     * const entryPoints = ['index', 'main'];
+     * await this.runDebug(entryPoints);
+     * ```
+     *
+     * In this example, the `runDebug` method runs the build process and spawns development processes for `index` and `main`.
+     *
+     * @public
+     */
+    runDebug(entryPoints: Array<string>): Promise<void>;
+    /**
+     * Serves the project and watches for changes.
+     * This method starts the development server using the `ServerProvider`, builds the project using esbuild,
+     * and watches for file changes to automatically rebuild as needed. It initializes the server and invokes
+     * the build process, enabling continuous development mode.
+     *
+     * @returns A promise that resolves when the server is started and the build process is complete.
+     *
+     * @throws This method catches any errors thrown during the build process and handles them using the
+     * `handleErrors` method.
+     *
+     * @example
+     * ```ts
+     * const buildService = new BuildService(config);
+     * buildService.serve().then(() => {
+     *     console.log('Server is running and watching for changes.');
+     * }).catch((error) => {
+     *     console.error('Failed to start the server:', error);
+     * });
+     * ```
+     *
+     * In this example, the `serve` method starts the server and watches for changes. If an error occurs during
+     * the build or server startup, it is handled and logged.
+     */
+    serve(): Promise<void>;
+    /**
+     * Executes a provided asynchronous callback function within a try-catch block.
+     * This method ensures that any errors thrown during the execution of the callback
+     * are properly handled and logged. If the error appears to be an `esbuild`-related
+     * `OnEndResult` error with an array of errors, it avoids redundant logging.
+     * Otherwise, it wraps the error in a `VMRuntimeError` and logs the stack trace.
+     *
+     * @template T - The return type of the callback function, allowing flexibility
+     *               in the expected result type. Defaults to `BuildResult`.
+     *
+     * @param callback - A function that returns a `Promise<T>`, which is executed asynchronously.
+     *                   The callback is wrapped in error handling logic to catch and process any exceptions.
+     *
+     * @returns A `Promise<T | void>` that resolves with the result of the callback function if successful,
+     *          or `void` if an error was thrown and handled. This allows for optional chaining on the return value.
+     *
+     * @throws This method does not throw explicitly but will log an error message if an exception is caught
+     *         and is not an `esbuild`-related error. The error stack is logged via `VMRuntimeError` for non-esbuild errors.
+     *
+     * @example
+     * ```ts
+     * await execute(async () => {
+     *   // Perform some asynchronous operation here
+     *   return someResult;
+     * });
+     * ```
+     */
+    private execute;
+    /**
+     * Configures the development mode by ensuring that `config.dev` is set properly.
+     */
+    private configureDevelopmentMode;
+    /**
+     * Sets up the plugin's provider and registers the plugin hooks.
+     */
+    private setupPlugins;
+    /**
+     * Registers the plugin hooks for start, end, and load events.
+     *
+     * @param paths - The resolved path aliases.
+     * @param rootDir - The root directory for resolving paths.
+     */
+    private registerPluginHooks;
+    /**
+     * Generates a path alias object from the TypeScript provider's path options.
+     * This method processes the `paths` property from the TypeScript provider's options,
+     * which is expected to be an object where each key represents a path alias pattern,
+     * and the corresponding value is an array of paths. The method removes any wildcard
+     * characters (`*`) from both the keys and the first values of the arrays. It also
+     * resolves the paths relative to the specified `rootDir`, returning a simplified
+     * object that maps the cleaned keys to their respective paths.
+     *
+     * The resolved paths will be formatted to use a relative path notation.
+     *
+     * Example:
+     * Given the following paths:
+     * ```ts
+     * {
+     *   '@core/*': ['src/core/*'],
+     *   '@utils/*': ['src/utils/*']
+     * }
+     * ```
+     * And assuming `rootDir` is set to the base directory of your project, the method
+     * will return:
+     * ```ts
+     * {
+     *   '@core/': './core/',
+     *   '@utils/': './utils/'
+     * }
+     * ```
+     *
+     * @param rootDir - The root directory to resolve paths against.
+     * @returns An object mapping cleaned path aliases to their respective resolved paths.
+     */
+    private generatePathAlias;
+    /**
+     * Handles errors during the build process.
+     * This method processes and logs errors that occur during the esbuild process. It specifically filters out
+     * errors related to TypeScript (`TypesError`) to prevent them from being logged, while logging all other errors
+     * to the console. The error object is assumed to contain a list of messages, each with detailed information.
+     *
+     * @param esbuildError - The error object returned by esbuild, which is expected to contain an array of
+     * error messages.
+     *
+     * @private
+     *
+     * @remarks
+     * - TypeScript errors (denoted as `TypesError`) are skipped and not logged.
+     * - Other errors are logged to the console with their text descriptions.
+     *
+     * @example
+     * ```ts
+     * try {
+     *     await buildService.run();
+     * } catch (esbuildError) {
+     *     buildService.handleErrors(esbuildError);
+     * }
+     * ```
+     *
+     * In this example, if an error occurs during the build process, the `handleErrors` method is used to
+     * process and log the errors.
+     */
+    private handleErrors;
+    /**
+     * Injects a configuration object (banner or footer) into the `esbuild` options.
+     * This method will update the `esbuild` object by adding or modifying the `banner` or `footer`
+     * property based on the provided configuration.
+     * The function handles both static values
+     * and functions within the configuration.
+     *
+     * @param esbuild - The `esbuild` configuration object where the `banner` or `footer`
+     *                  should be injected or updated.
+     * @param object - The configuration object that contains the properties to inject.
+     *                 The properties can either be static values or functions.
+     * @param name - A string that determines whether the method modifies the `banner` or `footer`
+     *               property of the `esbuild` object.
+     *
+     * @returns void - This method does not return any value.
+     * It modifies the `esbuild` object directly.
+     *
+     * @throws Error - If the `object` parameter is not provided, nothing is injected.
+     *                   No action will be taken if the specific `name` property (either
+     *                   'banner' or 'footer') does not exist in the `esbuild` object.
+     */
+    private injects;
+    /**
+     * Builds the project based on the configuration.
+     * Depending on the configuration, this method either uses esbuild's `context` for watching or `build` for a one-time build.
+     *
+     * @returns A promise that resolves with the build context or result.
+     *
+     * @private
+     */
+    private build;
+    /**
+     * Manages development processes for specified entry points.*
+     * This method spawns development processes for each file in the metafile that matches any of the specified entry points.
+     * It enables features like source maps and optional debugging mode for each spawned process.
+     *
+     * @param meta - The metafile containing information about build outputs.
+     * This typically includes a mapping of output files and their dependencies.
+     * @param entryPoint - An array of entry point file names to match against the metafile outputs.
+     * Only files that match these entry points will have development processes spawned.
+     * @param debug - A boolean flag to enable debugging mode for spawned processes.
+     * If `true`, the processes will start in debug mode with the `--inspect-brk` option. Defaults to `false`.
+     *
+     * @returns void
+     *
+     * @remarks
+     * - Files that contain 'map' in their names (e.g., source map files) are ignored and no process is spawned for them.
+     * - For each matching file in the metafile outputs, a new development process is spawned using the `spawn` function.
+     * - The `activePossess` array tracks all spawned processes, allowing further management (e.g., termination).
+     *
+     * @example
+     * ```ts
+     * const meta = {
+     *   outputs: {
+     *     'dist/index.js': { \/* ... *\/ },
+     *     'dist/index.js.map': { \/* ... *\/ }
+     *   }
+     * };
+     * const entryPoints = ['index'];
+     *
+     * this.spawnDev(meta, entryPoints, true); // Spawns processes in debug mode
+     * ```
+     *
+     * @private
+     */
+    private spawnDev;
+    /**
+     * Starts the build process and type checking.
+     * This method performs initial setup for the build and ensures that any child processes are terminated properly.
+     *
+     * @private
+     */
+    private start;
+    /**
+     * Finalizes the build process and logs results.
+     * This method handles the end of the build process, logs build results, and processes development files if applicable.
+     *
+     * @private
+     */
+    private end;
+    /**
+     * Processes and updates entry points based on project dependencies.
+     * This method analyzes the project's dependencies and adjusts entry points configuration as needed.
+     *
+     * @private
+     */
+    private processEntryPoints;
+}
+/**
+ * Main run function that initiates the build process based on CLI arguments.
+ *
+ * This function parses the CLI arguments, configures the build settings, and executes
+ * the appropriate build tasks, including type checking, serving, or running in debug mode.
+ *
+ * @param argv - An array of strings representing the CLI arguments.
+ *
+ * @returns A promise that resolves when all build tasks are completed.
+ *
+ * @example
+ * ```ts
+ * await buildWithArgv(process.argv);
+ * ```
+ */
+export declare function buildWithArgv(argv: Array<string>): Promise<void>;
+/**
+ * Builds the project using a configuration file specified by its path.
+ *
+ * This function reads the configuration from the provided file path, processes it,
+ * and initiates the build tasks.
+ *
+ * @param configFilePath - The path to the configuration file to be used for the build.
+ *
+ * @returns A promise that resolves to an array of `BuildResult` objects once all build tasks are completed.
+ *
+ * @throws Error Throws an error if the configuration file does not exist or is invalid.
+ *
+ * @example
+ * ```ts
+ * const results = await buildWithPath('./config.ts');
+ * console.log('Build results:', results);
+ * ```
+ */
+export declare function buildWithConfigPath(configFilePath: string): Promise<BuildResult[]>;
+/**
+ * Builds the project based on the provided configuration object.
+ *
+ * This function processes the given configuration and executes the build tasks accordingly.
+ *
+ * @param config - A partial configuration object used to define the build settings.
+ *
+ * @returns A promise that resolves to an array of `BuildResult` objects once all build tasks are completed.
+ *
+ * @example
+ * ```ts
+ * const results = await build({ entryPoints: ['./src/index.ts'] });
+ * console.log('Build results:', results);
+ * ```
+ */
+export declare function build(config: PartialDeepConfigurationsType): Promise<BuildResult[]>;