@lynx-js/rspeedy 0.8.7 → 0.9.1

package/dist/index.d.ts

@@ -0,0 +1,2971 @@
+/**
+ * @packageDocumentation
+ *
+ * The document contains all the configurations of the `@lynx-js/rspeedy` package.
+ *
+ * @example
+ *
+ * Use `lynx.config.ts` with {@link defineConfig} to get better TypeScript intellisense.
+ *
+ * ```ts
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: './src/index.tsx',
+ * })
+ * ```
+ */
+
+import type { CreateRsbuildOptions } from '@rsbuild/core';
+import type { DistPathConfig } from '@rsbuild/core';
+import { logger } from '@rsbuild/core';
+import type { PerformanceConfig } from '@rsbuild/core';
+import type { RsbuildConfig } from '@rsbuild/core';
+import type { RsbuildInstance } from '@rsbuild/core';
+import { RsbuildPlugin } from '@rsbuild/core';
+import { RsbuildPluginAPI } from '@rsbuild/core';
+import type { RsbuildPlugins } from '@rsbuild/core';
+import { version as rsbuildVersion } from '@rsbuild/core';
+import type { RsdoctorRspackPlugin } from '@rsdoctor/rspack-plugin';
+import { Rspack } from '@rsbuild/core';
+import { rspack } from '@rsbuild/core';
+import type { ToolsConfig } from '@rsbuild/core';
+import type { WatchFiles } from '@rsbuild/core';
+
+/**
+ * {@inheritdoc Performance.chunkSplit}
+ *
+ * @public
+ */
+export declare interface ChunkSplit {
+    /**
+     * The ChunkSplitting strategy.
+     *
+     * @remarks
+     *
+     * - `split-by-experience`(default): an empirical splitting strategy, automatically splits some commonly used npm packages into chunks of moderate size.
+     *
+     * - `split-by-module`: split by NPM package granularity, each NPM package corresponds to a chunk.
+     *
+     * - `split-by-size`: automatically split according to module size.
+     *
+     * - `all-in-one`: bundle all codes into one chunk.
+     *
+     * - `single-vendor`: bundle all NPM packages into a single chunk.
+     *
+     * - `custom`: custom chunk splitting strategy.
+     *
+     * @example
+     *
+     * - Use `all-in-one` to put all modules in one chunk.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'all-in-one',
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use `single-vendor` to put all third-party dependencies in one chunk. And source code in another chunk.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'single-vendor',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    strategy?: 'all-in-one' | 'split-by-module' | 'split-by-experience' | 'single-vendor' | undefined;
+    /**
+     * Custom Rspack chunk splitting config can be specified.
+     *
+     * @example
+     *
+     * - Split `@lynx-js/react` and `react-router` into chunk `lib-react`.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'split-by-experience',
+     *       override: {
+     *         cacheGroups: {
+     *           react: {
+     *             test: /node_modules[\\/](@lynx-js[\\/]react|react-router)[\\/]/,
+     *             name: 'lib-react',
+     *             chunks: 'all',
+     *           },
+     *         },
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    override?: Rspack.Configuration extends {
+        optimization?: {
+            splitChunks?: infer P;
+        } | undefined;
+    } ? P : never;
+}
+
+/**
+ * {@inheritdoc Performance.chunkSplit}
+ *
+ * @public
+ */
+export declare interface ChunkSplitBySize {
+    /**
+     * {@inheritdoc ChunkSplit.strategy}
+     */
+    strategy: 'split-by-size';
+    /**
+     * The minimum size of a chunk, unit in bytes. Defaults to `10000`.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'split-by-size',
+     *       minSize: 20000,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    minSize?: number | undefined;
+    /**
+     * The maximum size of a chunk, unit in bytes. Defaults to `Number.POSITIVE_INFINITY`.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'split-by-size',
+     *       maxSize: 50000,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    maxSize?: number | undefined;
+    /**
+     * {@inheritdoc ChunkSplit.override}
+     */
+    override?: Rspack.Configuration extends {
+        optimization?: {
+            splitChunks?: infer P;
+        } | undefined;
+    } ? P : never;
+}
+
+/**
+ * {@inheritdoc Performance.chunkSplit}
+ *
+ * @public
+ */
+export declare interface ChunkSplitCustom {
+    /**
+     * {@inheritdoc ChunkSplit.strategy}
+     */
+    strategy: 'custom';
+    /**
+     * {@inheritdoc ChunkSplit.override}
+     *
+     * @example
+     *
+     * - Split `@lynx-js/react` and `react-router` into chunk `lib-react`.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     chunkSplit: {
+     *       strategy: 'custom',
+     *       splitChunks: {
+     *         cacheGroups: {
+     *           react: {
+     *             test: /node_modules[\\/](@lynx-js[\\/]react|react-router)[\\/]/,
+     *             name: 'lib-react',
+     *             chunks: 'all',
+     *           },
+     *         },
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    splitChunks?: Rspack.Configuration extends {
+        optimization?: {
+            splitChunks?: infer P;
+        } | undefined;
+    } ? P : never;
+}
+
+/**
+ * The `Config` is the configuration that `rspeedy` uses.
+ *
+ * @public
+ */
+export declare interface Config {
+    /**
+     * The Rsbuild provider.
+     *
+     * @example
+     * You can switch from Rspack to Webpack by:
+     *
+     * - Use `webpackProvider` from `@rsbuild/webpack`
+     * - Add `pluginSwc` from `@rsbuild/plugin-webpack-swc` for TypeScript transpilation
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * import { webpackProvider } from '@rsbuild/webpack'
+     * import { pluginSwc } from '@rsbuild/plugin-webpack-swc'
+     *
+     * export default defineConfig({
+     *   provider: webpackProvider,
+     *   plugins: [
+     *     pluginSwc(),
+     *   ],
+     * })
+     * ```
+     *
+     * @alpha
+     */
+    provider?: RsbuildConfig['provider'];
+    /**
+     * The {@link Dev} option is used to control the behavior related with development. Including: HMR, DevServer, etc.
+     */
+    dev?: Dev | undefined;
+    /**
+     * The {@link Config.environments} option is used to set the output environment.
+     *
+     * @remarks
+     *
+     * Normally you don't need this if you are not using Lynx for Web.
+     *
+     * @example
+     *
+     * - Using different entries for Lynx and Web.
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   environments: {
+     *     lynx: {},
+     *     web: {
+     *       source: { entry: { web: './src/index.web.jsx' } },
+     *     },
+     *   },
+     *   source: {
+     *     entry: './src/index.jsx',
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Building Web-only outputs.
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   environments: {
+     *     web: {
+     *       source: { entry: { web: './src/index.web.jsx' } },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    environments?: RsbuildConfig['environments'] | undefined;
+    /**
+     * Specify the build mode for Rsbuild and Rspack, as each mode has different default behavior and optimizations.
+     *
+     * @remarks
+     *
+     * The default value of mode depends on the `process.env.NODE_ENV` environment variable:
+     *
+     * - If `NODE_ENV` is production, the default value is production.
+     *
+     * - If `NODE_ENV` is development, the default value is development.
+     *
+     * - If `NODE_ENV` has any other value, the default value is none.
+     *
+     * - If you set the value of mode, the value of `NODE_ENV` will be ignored.
+     *
+     * When using Rspeedy's CLI:
+     *
+     * - `rspeedy dev` and `rspeedy preview` will set the default values of `NODE_ENV` and `mode` to `'development'`.
+     *
+     * - `rspeedy build` will set the default values of `NODE_ENV` and `mode` to `'production'`.
+     *
+     * @example
+     *
+     * If the value of `mode` is `'development'`:
+     *
+     * - Enable HMR and register the {@link https://rspack.dev/plugins/webpack/hot-module-replacement-plugin | HotModuleReplacementPlugin}.
+     *
+     * - Generate JavaScript source maps, but do not generate CSS source maps. See {@link Output.sourceMap} for details.
+     *
+     * - The `process.env.NODE_ENV` in the source code will be replaced with `'development'`.
+     *
+     * - The `import.meta.env.MODE` in the source code will be replaced with `'development'`.
+     *
+     * - The `import.meta.env.DEV` in the source code will be replaced with `true`.
+     *
+     * - The `import.meta.env.PROD` in the source code will be replaced with `false`.
+     *
+     * @example
+     *
+     * If the value of `mode` is `'production'`:
+     *
+     * - Enable JavaScript code minification and register the {@link https://rspack.dev/plugins/rspack/swc-js-minimizer-rspack-plugin | SwcJsMinimizerRspackPlugin}.
+     *
+     * - Generated JavaScript and CSS filenames will have hash suffixes, see {@link Output.filenameHash}.
+     *
+     * - Generated CSS Modules classnames will be shorter, see {@link CssModules.localIdentName}.
+     *
+     * - Do not generate JavaScript and CSS source maps, see {@link Output.sourceMap}.
+     *
+     * - The `process.env.NODE_ENV` in the source code will be replaced with `'production'`.
+     *
+     * - The `import.meta.env.MODE` in the source code will be replaced with `'production'`.
+     *
+     * - The `import.meta.env.DEV` in the source code will be replaced with `false`.
+     *
+     * - The `import.meta.env.PROD` in the source code will be replaced with `true`.
+     */
+    mode?: 'development' | 'production' | 'none' | undefined;
+    /**
+     * The {@link Output} option is used to set how and where should the bundles and assets output.
+     */
+    output?: Output | undefined;
+    /**
+     * The {@link Performance} option is used to
+     */
+    performance?: Performance | undefined;
+    /**
+     * The {@link Server} option changes the behavior of dev-server.
+     */
+    server?: Server | undefined;
+    /**
+     * The {@link Source} option changes the behavior of source files.
+     */
+    source?: Source | undefined;
+    /**
+     * The {@link Tools} options changes the behavior of various building tools.
+     */
+    tools?: Tools | undefined;
+    /**
+     * The `plugins` option is used to customize the build process in a variety of ways.
+     *
+     * @remarks
+     * Rspeedy use the plugin APIs from {@link https://rsbuild.dev/plugins/dev/index | Rsbuild}. See the corresponding document for developing a plugin.
+     */
+    plugins?: RsbuildPlugins | undefined;
+}
+
+/**
+ * The type of the console method.
+ *
+ * @public
+ */
+export declare type ConsoleType = 'log' | 'warn' | 'error' | 'info' | 'debug' | 'profile' | 'profileEnd' | (string & Record<never, never>);
+
+/**
+ * The `createRspeedy` method can let you create a Rspeedy instance and you can customize the build or development process in Node.js Runtime.
+ *
+ * @param options - {@link CreateRspeedyOptions}
+ * @returns - Rspeedy instance.
+ *
+ * @example
+ *
+ * ```ts
+ * import { createRspeedy } from '@lynx-js/rspeedy'
+ *
+ * void async function () {
+ *   const rspeedy = await createRspeedy({})
+ *   await rspeedy.build()
+ * }()
+ * ```
+ *
+ * @public
+ */
+export declare function createRspeedy({ cwd, rspeedyConfig, loadEnv, environment }: CreateRspeedyOptions): Promise<RspeedyInstance>;
+
+/**
+ * The options of `createRspeedy` method.
+ *
+ * @public
+ */
+export declare interface CreateRspeedyOptions {
+    /**
+     * The root path of the current build.
+     */
+    cwd?: string;
+    /**
+     * The config of Rspeedy.
+     */
+    rspeedyConfig?: Config;
+    /**
+     * Rspeedy automatically loads the .env file by default, utilizing the [Rsbuild API](https://rsbuild.dev/api/javascript-api/core#load-env-variables).
+     * You can use the environment variables defined in the .env file within your code by accessing them via `import.meta.env.FOO` or `process.env.Foo`.
+     * @see https://rsbuild.dev/guide/advanced/env-vars#env-file
+     * @defaultValue true
+     */
+    loadEnv?: CreateRsbuildOptions['loadEnv'];
+    /**
+     * Only build specified environments.
+     * For example, passing `['lynx']` will only build the `lynx` environment.
+     * If not specified or passing an empty array, all environments will be built.
+     * @see https://rsbuild.dev/guide/advanced/environments#build-specified-environment
+     * @defaultValue []
+     */
+    environment?: CreateRsbuildOptions['environment'];
+}
+
+/**
+ * {@inheritdoc Tools.cssExtract}
+ *
+ * @public
+ */
+export declare interface CssExtract {
+    /**
+     * {@inheritdoc @lynx-js/css-extract-webpack-plugin#LoaderOptions}
+     */
+    loaderOptions?: CssExtractRspackLoaderOptions | undefined;
+    /**
+     * {@inheritdoc @lynx-js/css-extract-webpack-plugin#CssExtractRspackPluginOptions}
+     */
+    pluginOptions?: CssExtractRspackPluginOptions | undefined;
+}
+
+/**
+ * {@inheritdoc @lynx-js/css-extract-webpack-plugin#LoaderOptions}
+ *
+ * @public
+ */
+export declare interface CssExtractRspackLoaderOptions {
+    /**
+     * The same as {@link https://github.com/webpack-contrib/mini-css-extract-plugin#esModule}.
+     * By default, `@lynx-js/css-extract-webpack-plugin` generates JS modules that use the ES modules syntax.
+     * There are some cases in which using ES modules is beneficial,
+     * like in the case of module concatenation and tree shaking.
+     *
+     * @example
+     * You can enable a CommonJS syntax using:
+     *
+     * ```js
+     * import {CssExtractWebpackPlugin} from "@lynx-js/css-extract-webpack-plugin";
+     * export default {
+     *   plugins: [new CssExtractWebpackPlugin()],
+     *   module: {
+     *     rules: [
+     *       {
+     *         test: /\.css$/i,
+     *         use: [
+     *           {
+     *             loader: CssExtractWebpackPlugin.loader,
+     *             options: {
+     *               esModule: false,
+     *             },
+     *           },
+     *           "css-loader",
+     *         ],
+     *       },
+     *     ],
+     *   },
+     * };
+     * ```
+     *
+     * @public
+     */
+    esModule?: boolean | undefined;
+}
+
+/**
+ * {@inheritdoc @lynx-js/css-extract-webpack-plugin#CssExtractRspackPluginOptions}
+ *
+ * @public
+ */
+export declare interface CssExtractRspackPluginOptions {
+    /**
+     * {@inheritdoc @lynx-js/css-extract-webpack-plugin#CssExtractRspackPluginOptions.ignoreOrder}
+     */
+    ignoreOrder?: boolean | undefined;
+    /**
+     * {@inheritdoc @lynx-js/css-extract-webpack-plugin#CssExtractRspackPluginOptions.pathinfo}
+     */
+    pathinfo?: boolean | undefined;
+}
+
+/**
+ * {@inheritdoc Tools.cssLoader}
+ *
+ * @public
+ */
+export declare interface CssLoader {
+    /**
+     * The option `importLoaders` allows you to configure how many loaders before `css-loader` should be applied to `@imported` resources and CSS modules imports.
+     *
+     * @remarks
+     *
+     * The default value of `importLoaders` is:
+     *
+     * - `1` when compiling CSS files
+     *
+     * - `2` when compiling Sass or Less files
+     *
+     * See {@link https://github.com/webpack-contrib/css-loader?tab=readme-ov-file#importloaders | css-loader#import-loaders} for details.
+     */
+    importLoaders?: 0 | 1 | 2 | undefined;
+    /**
+     * The {@link CssLoaderModules | cssLoader.modules} option enables/disables the CSS Modules specification and setup basic behavior.
+     *
+     * @example
+     *
+     * Using `false` value to increase performance because we avoid parsing CSS Modules features, it will be useful for developers who use vanilla css or use other technologies.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     cssLoader: {
+     *       modules: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Using `() => true` value to enable CSS Modules for all files.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     cssLoader: {
+     *       modules: () => true,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Using object value to enable CSS Modules based-on {@link CssLoaderModules.auto} option and setup more configurations about CSS Modules.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     cssLoader: {
+     *       modules: {
+     *         namedExport: true,
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    modules?: boolean | CssLoaderModules | undefined;
+}
+
+/**
+ * {@inheritdoc CssLoader.modules}
+ *
+ * @public
+ */
+export declare interface CssLoaderModules {
+    /**
+     * {@inheritdoc CssModules.auto}
+     */
+    auto?: boolean | RegExp | ((filename: string) => boolean) | undefined;
+    /**
+     * {@inheritdoc CssModules.exportLocalsConvention}
+     */
+    exportLocalsConvention?: CssModuleLocalsConvention | undefined;
+    /**
+     * {@inheritdoc CssModules.localIdentName}
+     */
+    localIdentName?: string | undefined;
+    /**
+     * Enables/disables ES modules named export for locals.
+     *
+     * @example
+     *
+     * - `style.css`
+     *
+     * ```css
+     * .foo-baz {
+     *   color: red;
+     * }
+     * .bar {
+     *   color: blue;
+     * }
+     * .default {
+     *   color: green;
+     * }
+     * ```
+     *
+     * - `index.js`
+     *
+     * ```js
+     * import * as styles from "./styles.css";
+     *
+     * // If using `exportLocalsConvention: "as-is"` (default value):
+     * console.log(styles["foo-baz"], styles.bar);
+     *
+     * // If using `exportLocalsConvention: "camel-case-only"`:
+     * console.log(styles.fooBaz, styles.bar);
+     *
+     * // For the `default` class name
+     * console.log(styles["_default"]);
+     * ```
+     */
+    namedExport?: boolean | undefined;
+}
+
+/**
+ * {@inheritdoc CssModules.exportLocalsConvention}
+ *
+ * @public
+ */
+export declare type CssModuleLocalsConvention = 'asIs' | 'camelCase' | 'camelCaseOnly' | 'dashes' | 'dashesOnly';
+
+/**
+ * {@inheritdoc Output.cssModules}
+ *
+ * @public
+ */
+export declare interface CssModules {
+    /**
+     * The `auto` option allows CSS modules to be automatically enabled based on their filenames.
+     *
+     * @remarks
+     *
+     * Given the various `auto` values, the behavior is described as follows:
+     *
+     * - `true`: enable CSS modules for all files matching `/\.module\.\w+$/i.test(filename)` RegExp.
+     *
+     * - `false`: disable CSS modules.
+     *
+     * - `RegExp`: enable CSS modules for all files matching the `auto.test(filename)` RegExp.
+     *
+     * - `function`: enable CSS modules based on the filter function.
+     *
+     * See {@link https://github.com/webpack-contrib/css-loader?tab=readme-ov-file#auto | css-loader#auto} for details.
+     *
+     * @example
+     *
+     * Enable CSS module for `*.module.css` and `shared/*.css`:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     cssModules: {
+     *       auto: (filename) => {
+     *         return filename.includes('.module.') || filename.includes('shared/')
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    auto?: boolean | RegExp | ((filename: string) => boolean) | undefined;
+    /**
+     * Allows exporting names from global class names, so you can use them via import.
+     *
+     * @remarks
+     *
+     * See {@link https://github.com/webpack-contrib/css-loader?tab=readme-ov-file#exportglobals | css-loader#exportGlobals} for details.
+     */
+    exportGlobals?: boolean | undefined;
+    /**
+     * The style of exported class names.
+     *
+     * @remarks
+     *
+     * Given the various `exportLocalsConvention` values, the behavior is described as follows:
+     *
+     * - `'asIs'`:	Class names will be exported as is.
+     *
+     * - `'camelCase'`: Class names will be camelized, the original class name will not to be removed from the locals
+     *
+     * - `'camelCaseOnly'`: Class names will be camelized, the original class name will be removed from the locals
+     *
+     * - `'dashes'`: Only dashes in class names will be camelized
+     *
+     * - `'dashesOnly'`: Dashes in class names will be camelized, the original class name will be removed from the locals
+     *
+     * See {@link https://github.com/webpack-contrib/css-loader?tab=readme-ov-file#exportlocalsconvention | css-loader#exportLocalsConvention} for details.
+     */
+    exportLocalsConvention?: CssModuleLocalsConvention | undefined;
+    /**
+     * Sets the format of the className generated by CSS Modules after compilation.
+     *
+     * @remarks
+     *
+     * See {@link https://github.com/webpack-contrib/css-loader?tab=readme-ov-file#localIdentName | css-loader#localIdentName} for details.
+     */
+    localIdentName?: string | undefined;
+}
+
+/**
+ * {@inheritdoc Source.decorators}
+ *
+ * @public
+ */
+export declare interface Decorators {
+    /**
+     * Specify the decorator syntax version to be used.
+     *
+     * @remarks
+     *
+     * If you want to know the differences between different decorators versions, you can refer to: {@link https://github.com/tc39/proposal-decorators?tab=readme-ov-file#how-does-this-proposal-compare-to-other-versions-of-decorators | How does this proposal compare to other versions of decorators?}
+     *
+     * @example
+     *
+     * `'2022-03'` corresponds to the Stage 3 decorator proposal, equivalent to the decorator syntax supported by TypeScript 5.0 by default.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   source: {
+     *     decorators: { version: '2022-03' },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * `'legacy'` corresponds to TypeScript's `experimentalDecorators: true`.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   source: {
+     *     decorators: { version: 'legacy' },
+     *   },
+     * })
+     * ```
+     */
+    version?: 'legacy' | '2022-03';
+}
+
+/**
+ * The `defineConfig` method is a helper function used to get TypeScript intellisense.
+ *
+ * @param config - The config of Rspeedy.
+ * @returns - The identical config as the input config.
+ *
+ * @example
+ *
+ * Use `defineConfig` in `lynx.config.ts`:
+ *
+ * ```ts
+ * //@ts-check
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   // autocompletion works here!
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function defineConfig(config: Config): Config;
+
+/**
+ * {@inheritdoc Config.dev}
+ * @public
+ */
+export declare interface Dev {
+    /**
+     * The {@link Dev.assetPrefix} is used to set the URL prefix for static assets during development.
+     * @remarks
+     *
+     * The functionality of {@link Dev.assetPrefix} is basically the same as the {@link https://www.rspack.dev/config/output#outputpublicpath | output.publicPath}
+     * config in Rspack. With the following differences:
+     *
+     * - `dev.assetPrefix` only takes effect during development.
+     *
+     * - `dev.assetPrefix` automatically appends a trailing `/` by default.
+     *
+     * - The value of `dev.assetPrefix` is written to the `process.env.ASSET_PREFIX` environment variable.
+     *
+     * @example
+     *
+     * If `dev.assetPrefix` is set to true, the URL prefix will be `http://<host>:<port>/`:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: true,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * If `dev.assetPrefix` is set to a string, the value will be used as a prefix and automatically appended to the static resource URL.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: 'https://example.com/assets/',
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * The port number that Rspeedy server listens on may change. For example, if the port is in use, Rspeedy will automatically increment the port number until it finds an available port.
+     *
+     * To avoid `dev.assetPrefix` becoming invalid due to port changes, you can use one of the following methods:
+     *
+     * - Enable `server.strictPort`.
+     *
+     * - Use the `<port>` placeholder to refer to the current port number. Rspeedy will replace the placeholder with the actual port number it is listening on.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     assetPrefix: 'https://example.com:<port>/assets/',
+     *   },
+     * })
+     * ```
+     */
+    assetPrefix?: string | boolean | undefined;
+    /**
+     * Configuration of the development client.
+     */
+    client?: DevClient | undefined;
+    /**
+     * Whether to enable Hot Module Replacement (HMR).
+     *
+     * @remarks
+     *
+     * Defaults to `true`.
+     *
+     * By default, Rspeedy uses HMR as the preferred method to update modules. If HMR is disabled or cannot be used in certain scenarios, it will automatically fallback to {@link Dev.liveReload}.
+     *
+     * To completely disable both HMR and live reload, set both `dev.hmr` and `dev.liveReload` to `false`. Then, no WebSocket requests will be made to the dev server on the page, and the page will not automatically refresh when file changes.
+     *
+     * @example
+     *
+     * Disable HMR:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     hmr: false,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Disable both HMR and live reload:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     hmr: false,
+     *     liveReload: false,
+     *   },
+     * })
+     * ```
+     */
+    hmr?: boolean | undefined;
+    /**
+     * Whether to enable live reload functionality.
+     *
+     * Defaults to `true`.
+     *
+     * Live reload is used as a fallback when {@link Dev.hmr} is disabled or cannot be used in certain scenarios. When enabled, the page will automatically refresh when source files are changed.
+     *
+     * To completely disable both HMR and live reload, set both `dev.hmr` and `dev.liveReload` to `false`. Then, no WebSocket requests will be made to the dev server on the page, and the page will not automatically refresh when file changes.
+     *
+     * @example
+     *
+     * Disable live reload:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     liveReload: false,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Disable both HMR and live reload:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     hmr: false,
+     *     liveReload: false,
+     *   },
+     * })
+     * ```
+     */
+    liveReload?: boolean | undefined;
+    /**
+     * Watch specified files and directories for changes. When a file change is detected, it can trigger a page reload or restart the dev server.
+     *
+     * @example
+     *
+     * - Specify the files and directories watched for changes.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     watchFiles: {
+     *       paths: ['src/**', 'public/**'],
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use {@link https://github.com/paulmillr/chokidar#api | chokidar} options for watching.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     watchFiles: {
+     *       paths: ['src/**', 'public/**'],
+     *       options: { usePolling: false },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    watchFiles?: WatchFiles | WatchFiles[] | undefined;
+    /**
+     * Used to control whether the build artifacts of the development environment are written to the disk.
+     *
+     * @remarks
+     *
+     * This is bypassed to {@link https://github.com/webpack/webpack-dev-middleware?tab=readme-ov-file#writetodisk | `webpack-dev-middleware`}.
+     *
+     * Setting `writeToDisk: true` won't change the behavior of the `webpack-dev-middleware`, and bundle files accessed through the browser will still be served from memory.
+     *
+     * This option also accepts a `Function` value, which can be used to filter which files are written to disk.
+     *
+     * The function follows the same premise as `Array#filter` in which a return value of `false` will not write the file, and a return value of `true` will write the file to disk.
+     *
+     * @example
+     * ```js
+     * // lynx.config.ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   dev: {
+     *     writeToDisk: (filePath) => /superman\.css$/.test(filePath),
+     *   },
+     * })
+     * ```
+     */
+    writeToDisk?: boolean | ((filename: string) => boolean) | undefined;
+    /**
+     * Whether to display progress bar during compilation.
+     *
+     * Defaults to `true`.
+     *
+     * @example
+     *
+     * Disable the progress bar.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     progressBar: false,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Modify the progress bar `id`
+     *
+     * To modify the text displayed on the left side of the progress bar, set the `id` option:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   dev: {
+     *     progressBar: {
+     *       id: 'Some Text'
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    progressBar?: boolean | {
+        id?: string;
+    } | undefined;
+}
+
+/**
+ * {@inheritdoc Dev.client}
+ *
+ * @public
+ */
+export declare interface DevClient {
+    /**
+     * The path to websocket.
+     *
+     * @remarks
+     *
+     * Defaults to `require.resolve('@lynx-js/websocket')`
+     */
+    websocketTransport?: string | undefined;
+}
+
+/**
+ * {@inheritdoc Output.distPath}
+ *
+ * @public
+ */
+export declare interface DistPath extends DistPathConfig {
+    /**
+     * The output directory of the intermediate files.
+     *
+     * @remarks
+     *
+     * Default value:
+     *
+     * - `'.rspeedy'`
+     */
+    intermediate?: string | undefined;
+}
+
+/**
+ * {@inheritdoc Source.entry}
+ *
+ * @example
+ *
+ * - Use a single entry:
+ *
+ * ```js
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: './src/pages/main/index.js',
+ * })
+ * ```
+ *
+ * @example
+ *
+ * - Use a single entry with multiple entry modules:
+ *
+ * ```js
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: ['./src/prefetch.js', './src/pages/main/index.js'],
+ * })
+ * ```
+ *
+ * @example
+ *
+ * - Use multiple entries(with multiple entry modules):
+ *
+ * ```js
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: {
+ *     foo: './src/pages/foo/index.js',
+ *     bar: ['./src/pages/bar/index.js', './src/post.js'], // multiple entry modules is allowed
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ *
+ * - Use multiple entries with {@link EntryDescription}:
+ *
+ * ```js
+ * import { defineConfig } from '@lynx-js/rspeedy'
+ * export default defineConfig({
+ *   entry: {
+ *     foo: './src/pages/foo/index.js',
+ *     bar: {
+ *       import: ['./src/prefetch.js', './src/pages/bar'],
+ *     },
+ *   },
+ * })
+ * ```
+ * @public
+ */
+export declare type Entry = string | string[] | Record<string, string | string[] | EntryDescription>;
+
+/**
+ * The `EntryDescription` describes a entry. It is useful when the project has multiple entries with different configuration.
+ *
+ * @remarks
+ * It is similar with the {@link https://www.rspack.dev/config/entry#entry-description-object | Entry Description Object} of Rspack.
+ * But only a few properties that Lynx supports is allowed.
+ *
+ * @public
+ */
+export declare interface EntryDescription {
+    /**
+     * The path to the entry module(s).
+     *
+     * @remarks
+     *
+     * If no value is provided, the default value `src/index.js` will be used.
+     *
+     * @defaultValue `'./src/index.js'`
+     */
+    import?: string | string[] | undefined;
+    /**
+     * This is an important option when using on-demand-loading or loading external resources like images, files, etc. If an incorrect value is specified you'll receive 404 errors while loading these resources.
+     *
+     * @see https://webpack.js.org/configuration/output/#outputpublicpath
+     */
+    publicPath?: string | undefined;
+}
+
+/**
+ * The exposed API of Rspeedy. Can be used in Rsbuild plugin with {@link https://rsbuild.dev/plugins/dev/core#apiuseexposed | api.useExposed}.
+ *
+ * @public
+ *
+ * @example
+ *
+ * ```ts
+ * import type { ExposedAPI } from '@lynx-js/rspeedy'
+ * const RsbuildPlugin = {
+ *   name: 'my-rsbuild-plugin',
+ *   pre: ['lynx:rsbuild:plugin-api'],
+ *   setup(api) {
+ *     const rspeedyAPI = api.useExposed<ExposedAPI>(Symbol.for('rspeedy.api'))
+ *   },
+ * }
+ * ```
+ */
+export declare interface ExposedAPI {
+    /**
+     * The user config.
+     */
+    config: Config;
+    /**
+     * Print debug logs.
+     *
+     * @param message - The printed message.
+     */
+    debug: (message: string | (() => string)) => void;
+    /**
+     * Exit the process.
+     *
+     * @param code - The exit code.
+     */
+    exit: (code?: number) => Promise<void> | void;
+    /**
+     * Get the Rspeedy logger.
+     */
+    logger: typeof logger;
+    /**
+     * The version of Rspeedy.
+     */
+    version: string;
+}
+
+/**
+ * {@inheritdoc Output.filename}
+ *
+ * @public
+ */
+export declare interface Filename {
+    /**
+     * The name of the bundle files.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].[platform].bundle'`
+     *
+     * The following placeholder is supported:
+     *
+     * - `[name]`: the name of the entry.
+     * - `[contenthash]`: the contenthash of the bundle.
+     * - `[platform]`: the environment name of the bundle.
+     *
+     * @example
+     *
+     * - Using content hash in bundle filename:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filename: {
+     *       bundle: '[name].[contenthash].bundle',
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Using content hash with length in bundle filename:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filename: {
+     *       bundle: '[name].[contenthash:8].bundle',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    bundle?: string | undefined;
+    /**
+     * The name of the template files.
+     *
+     * @deprecated
+     *
+     * Use {@link Filename.bundle} instead.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].lynx.bundle'`
+     *
+     * The following placeholder is supported:
+     *
+     * - `[name]`: the name of the entry.
+     * - `[contenthash]`: the contenthash of the template.
+     *
+     * @example
+     *
+     * - Using content hash in bundle filename:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filename: {
+     *       template: '[name].[contenthash].bundle',
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Using content hash with length in bundle filename:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filename: {
+     *       template: '[name].[contenthash:8].bundle',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    template?: string | undefined;
+    /**
+     * The name of the JavaScript files.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - Development: `'[name].js'`
+     * - Production: `'[name].[contenthash:8].js'`
+     */
+    js?: string | undefined;
+    /**
+     * The name of the CSS files.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].css'`
+     */
+    css?: string | undefined;
+    /**
+     * The name of the SVG images.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].[contenthash:8].svg'`
+     */
+    svg?: string | undefined;
+    /**
+     * The name of the font files.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].[contenthash:8][ext]'`
+     */
+    font?: string | undefined;
+    /**
+     * The name of non-SVG images.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].[contenthash:8][ext]'`
+     */
+    image?: string | undefined;
+    /**
+     * The name of media assets, such as video.
+     *
+     * @remarks
+     *
+     * Default values:
+     *
+     * - `'[name].[contenthash:8][ext]'`
+     */
+    media?: string | undefined;
+}
+
+/**
+ * Load the build config by the config path.
+ *
+ * @param loadConfigOptions - the options of `loadConfig` method.
+ * @returns Build config.
+ *
+ * @example
+ *
+ * ```ts
+ * import { loadConfig } from '@lynx-js/rspeedy'
+ *
+ * void async function () {
+ *   const config = await loadConfig({ configPath: './lynx.config.js' })
+ *   console.log(config);
+ * }()
+ * ```
+ *
+ * @public
+ */
+export declare function loadConfig(loadConfigOptions: LoadConfigOptions): Promise<LoadConfigResult>;
+
+/**
+ * The options of loadConfig.
+ *
+ * @public
+ */
+export declare interface LoadConfigOptions {
+    configPath?: string | undefined;
+    cwd?: string | undefined;
+}
+
+/**
+ * The result of {@link loadConfig}.
+ *
+ * @public
+ */
+export declare interface LoadConfigResult {
+    /**
+     * The configuration object that exported from the configuration file.
+     *
+     * @remarks
+     *
+     * The returned object has already been validated.
+     */
+    content: Config;
+    /**
+     * The configuration path that has been loaded.
+     */
+    configPath: string;
+}
+
+export { logger }
+
+/**
+ * Merge multiple Rspeedy configuration objects.
+ *
+ * @param configs - The Rspeedy configuration objects to merge.
+ *
+ * @returns The merged Rspeedy configuration object.
+ *
+ * @example
+ *
+ * ```ts
+ * import { mergeRspeedyConfig } from '@lynx-js/rspeedy';
+ *
+ * const config1 = {
+ *   dev: {
+ *     writeToDisk: false,
+ *   },
+ * };
+ * const config2 = {
+ *   dev: {
+ *     writeToDisk: true,
+ *   },
+ * };
+ *
+ * const mergedConfig = mergeRspeedyConfig(config1, config2);
+ *
+ * console.log(mergedConfig); // { dev: { writeToDisk: true } }
+ * ```
+ *
+ * @remarks
+ *
+ * This is actually an alias of {@link https://rsbuild.dev/api/javascript-api/core#mergersbuildconfig | mergeRsbuildConfig}.
+ *
+ * @public
+ */
+export declare function mergeRspeedyConfig(...configs: Config[]): Config;
+
+/**
+ * {@inheritdoc Output.minify}
+ *
+ * @public
+ */
+export declare interface Minify {
+    /**
+     * Whether enable the CSS minification.
+     *
+     * @remarks
+     *
+     * When building for production, {@link https://github.com/rspack-contrib/rsbuild-plugin-css-minimizer | @rsbuild/plugin-css-minimizer} is used to minify CSS assets for better transmission efficiency.
+     *
+     * @example
+     *
+     * - Disable the CSS minification.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     minify: {
+     *       css: false,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    css?: boolean | undefined;
+    /**
+     * Whether enable the JavaScript minification.
+     *
+     * @example
+     *
+     * - Disable the JavaScript minification.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     minify: {
+     *       js: false,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    js?: boolean | undefined;
+    /**
+     * {@link Minify.jsOptions} is used to configure SWC minification options.
+     *
+     * @remarks
+     *
+     * For detailed configurations, please refer to {@link https://rspack.dev/plugins/rspack/swc-js-minimizer-rspack-plugin | SwcJsMinimizerRspackPlugin}.
+     *
+     * @example
+     *
+     * - Disable the mangle feature.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     minify: {
+     *       jsOptions: {
+     *         minimizerOptions: {
+     *           mangle: false,
+     *         },
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    jsOptions?: Rspack.SwcJsMinimizerRspackPluginOptions | undefined;
+}
+
+/**
+ * {@inheritdoc Config.output}
+ * @public
+ */
+export declare interface Output {
+    /**
+     * The {@link Output.assetPrefix} is used to set the URL prefix for static assets.
+     *
+     * @remarks
+     *
+     * The functionality of {@link Output.assetPrefix} is basically the same as the {@link https://www.rspack.dev/config/output#outputpublicpath | output.publicPath}
+     * config in Rspack. With the following differences:
+     *
+     * - `output.assetPrefix` only takes effect in the production build.
+     *
+     * - `output.assetPrefix` automatically appends a trailing `/` by default.
+     *
+     * - The value of `output.assetPrefix` is written to the `process.env.ASSET_PREFIX` environment variable.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     assetPrefix: 'https://cdn.example.com/assets/',
+     *   },
+     * })
+     * ```
+     */
+    assetPrefix?: string | undefined;
+    /**
+     * The {@link Output.cleanDistPath} option determines whether all files in the output directory (default: `dist`) are removed before the build starts.
+     *
+     * @remarks
+     *
+     * By default, if the output directory is a subdirectory of the project root path, Rspeedy will automatically clean all files in the build directory.
+     *
+     * When {@link https://rsbuild.dev/config/output/dist-path#root-directory | output.distPath.root} is an external directory or the same as the project root directory, `cleanDistPath` is not enabled by default to prevent accidental deletion of files from other directories.
+     *
+     * @example
+     *
+     * - Disable cleaning files:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     cleanDistPath: false,
+     *   },
+     * })
+     * ```
+     * @example
+     *
+     * - Only clean files before the production build:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     cleanDistPath: process.env.NODE_ENV === 'production',
+     *   },
+     * })
+     * ```
+     */
+    cleanDistPath?: boolean | undefined;
+    /**
+     * The {@link Output.copy} option is used for copying files to the dist directory.
+     *
+     * @remarks
+     *
+     * For more options, see {@link https://rspack.dev/plugins/rspack/copy-rspack-plugin | Rspack.CopyRspackPlugin}.
+     *
+     * @example
+     *
+     * - Copy files from `./src/assets` to the `./dist` directory:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     copy: [
+     *       // `./src/assets/image.png` -> `./dist/image.png`
+     *       { from: './src/assets' },
+     *     ],
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Copy files from ./src/assets to the ./dist/assets directory:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     copy: [
+     *       // `./src/assets/image.png` -> `./dist/assets/image.png`
+     *       { from: './src/assets', to: 'assets' },
+     *     ],
+     *   },
+     * })
+     * ```
+     */
+    copy?: Rspack.CopyRspackPluginOptions | Rspack.CopyRspackPluginOptions['patterns'] | undefined;
+    /**
+     * The {@link CssModules} option is used for the customization of CSS Modules configurations.
+     *
+     * @remarks
+     *
+     * The CSS module is enabled for `*.module.css`, `*.module.scss` and `*.module.less`.
+     * Use {@link CssModules.auto} to customize the filtering behavior.
+     *
+     * @example
+     *
+     * Disable CSS modules:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     cssModules: {
+     *       auto: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Enable CSS modules for all CSS files:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     cssModules: {
+     *       auto: () => true,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    cssModules?: CssModules | undefined;
+    /**
+     * The {@link Output.dataUriLimit} option is used to set the size threshold to inline static assets such as images and fonts.
+     *
+     * @remarks
+     *
+     * The default value of `dataUriLimit` is 2kB.
+     *
+     * @example
+     *
+     * Inline all static assets less than 4kB:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     dataUriLimit: 4 * 1024,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Disable inlining of static assets:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     dataUriLimit: 0,
+     *   },
+     * })
+     * ```
+     * @example
+     *
+     * Inline all static assets:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     dataUriLimit: Number.MAX_SAFE_INTEGER,
+     *   },
+     * })
+     * ```
+     */
+    dataUriLimit?: number | undefined;
+    /**
+     * Set the directory of the dist files.
+     *
+     * @remarks
+     *
+     * More options can be found at {@link https://rsbuild.dev/config/output/dist-path | Rsbuild - distPath}.
+     *
+     * @example
+     *
+     * Use `output` instead of `dist`(the default value):
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     distPath: {
+     *       root: './output',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    distPath?: DistPath | undefined;
+    /**
+     * The {@link Filename} determines the name of the JavaScript bundle file to be output. These bundles will be written to the directory specified by output.path.
+     *
+     * @remarks
+     *
+     * If a string is provided, it will be used as {@link Filename.bundle}.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     filename: '[name]/[name].lynx.bundle',
+     *   },
+     * })
+     * ```
+     */
+    filename?: string | Filename | undefined;
+    /**
+     * The {@link Output.filenameHash} option controls whether to add a hash value to the filename after the production build.
+     *
+     * @remarks
+     *
+     * {@link Output.filename} has a higher priority than {@link Output.filenameHash}.
+     *
+     * @example
+     *
+     * - Disable hash
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filenameHash: false,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Change hash format
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     filenameHash: 'fullhash:16',
+     *   },
+     * })
+     * ```
+     *
+     * The available hash formats are:
+     *
+     * - `fullhash`: The hash value of the entire compilation. If any file changes, the hash values of all output files in the entire project will change.
+     *
+     * - `chunkhash`: The hash value of the chunk. The hash value will only change when the content of the chunk (and its included modules) changes.
+     *
+     * - `contenthash`: The hash value of the file content. The hash value will only change when the content of the file itself changes.
+     */
+    filenameHash?: boolean | string | undefined;
+    /**
+     * The {@link Output.legalComments} controls how to handle the legal comment.
+     *
+     * @remarks
+     *
+     * If no value is provided, the default value would be `'none'`.
+     *
+     * This is different with Rsbuild since we normally do not want a `.LEGAL.txt` file in Lynx outputs.
+     *
+     * This behavior can be configured by using one of the following options:
+     *
+     * - `linked`: Extract all legal comments to a `.LEGAL.txt` file and link to them with a comment.
+     *
+     * - `inline`: Preserve all legal comments in original position.
+     *
+     * - `none`: Remove all legal comments.
+     */
+    legalComments?: 'none' | 'inline' | 'linked' | undefined;
+    /**
+     * The {@link Minify} configures whether to enable code minification in the production build, or to configure minimizer options.
+     *
+     * @example
+     *
+     * Disable minification.
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   output: {
+     *     minify: false,
+     *   },
+     * })
+     * ```
+     */
+    minify?: Minify | boolean | undefined;
+    /**
+     * The {@link SourceMap} configures whether and how to generate source-map for outputs.
+     */
+    sourceMap?: boolean | SourceMap | undefined;
+}
+
+/**
+ * {@inheritdoc Config.performance}
+ *
+ * @public
+ */
+export declare interface Performance {
+    /**
+     * {@link Performance.chunkSplit} is used to configure the chunk splitting strategy.
+     */
+    chunkSplit?: ChunkSplit | ChunkSplitBySize | ChunkSplitCustom | undefined;
+    /**
+     * Whether to remove `console.[methodName]` in production build.
+     *
+     * @example
+     *
+     * - Remove all `console` methods
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     removeConsole: true,
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Remove specific `console` methods
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     removeConsole: ['log', 'warn']
+     *   },
+     * })
+     * ```
+     */
+    removeConsole?: boolean | ConsoleType[] | undefined;
+    /**
+     * Whether to print the file sizes after production build.
+     *
+     * {@link Performance.printFileSize}
+     *
+     * See {@link https://rsbuild.dev/config/performance/print-file-size | Rsbuild - performance.printFileSize} for details.
+     *
+     * @example
+     *
+     * If you don't want to print any information, you can disable it by setting printFileSize to false:
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: false
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Set total to false to disable total size output.
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: {
+     *       total: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * Set detail to false to disable per-asset size output.
+     *
+     * If you don't need to view the size of each static asset, you can set detail to false. In this case, only the total size will be output:
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: {
+     *       detail: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * If you don't need to view the gzipped size, you can set compressed to false. This can save some gzip computation time for large projects:
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: {
+     *       compressed: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * To include only static assets that meet certain criteria, use a filter function with include.
+     *
+     * If returned false, the static asset will be excluded and not included in the total size or detailed size.
+     *
+     * only output static assets larger than 10kB:
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: {
+     *       include: (asset) => asset.size > 10 * 1000,
+     *     }
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * To exclude static assets that meet certain criteria, use a filter function with exclude. If both include and exclude are set, exclude will take precedence.
+     *
+     * Rspeedy defaults to excluding source map, license files, and .d.ts type files, as these files do not affect page load performance.
+     *
+     * exclude .html files in addition to the default:
+     *
+     * ```ts
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   performance: {
+     *     printFileSize: {
+     *       exclude: (asset) =>
+     *         /\.(?:map|LICENSE\.txt)$/.test(asset.name) ||
+     *         /\.html$/.test(asset.name),
+     *     }
+     *   },
+     * })
+     * ```
+     */
+    printFileSize?: PerformanceConfig['printFileSize'] | undefined;
+}
+
+export { RsbuildPlugin }
+
+export { RsbuildPluginAPI }
+
+export { rsbuildVersion }
+
+export declare type RsdoctorRspackPluginOptions = ConstructorParameters<typeof RsdoctorRspackPlugin<[]>>[0];
+
+export { Rspack }
+
+export { rspack }
+
+export declare const rspackVersion: string;
+
+/**
+ * The instance of Rspeedy.
+ *
+ * @public
+ */
+export declare type RspeedyInstance = RsbuildInstance & {
+    getRspeedyConfig(): Config;
+};
+
+/**
+ * {@inheritdoc Config.server}
+ * @public
+ */
+export declare interface Server {
+    /**
+     * Configure the base path of the server.
+     *
+     * @remarks
+     * By default, the base path of the server is `/`, and users can access lynx bundle through `http://<host>:<port>/main.lynx.bundle`
+     *
+     * If you want to access lynx bundle through `http://<host>:<port>/foo/main.lynx.bundle`, you can change `server.base` to `/foo`
+     *
+     * you can refer to {@link https://rsbuild.dev/config/server/base | server.base } for more information.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   server: {
+     *     base: '/dist'
+     *   },
+     * })
+     * ```
+     */
+    base?: string | undefined;
+    /**
+     * Adds headers to all responses.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   server: {
+     *     headers: {
+     *       'Access-Control-Allow-Origin': '**',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    headers?: Record<string, string | string[]> | undefined;
+    /**
+     * Specify the host that the Rspeedy Server listens to.
+     *
+     * @remarks
+     * By default, the server listens on local network IP, for example, `192.168.1.50`, verify your local net IP by the command `ifconfig` on your system for (en0 for MacOS and eth0 for LinuxOS users). In case you have multiple local network IP(s) particularly when you are running dockers on the host machine, then you can specify your desired host IP.
+     *
+     * @example
+     *
+     * Set the host to a custom value:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   server: {
+     *     host: "192.168.1.50",
+     *   },
+     * })
+     * ```
+     */
+    host?: string | undefined;
+    /**
+     * Specify the port that the Rspeedy Server listens to.
+     *
+     * @remarks
+     * By default, the server listens on port `3000` and automatically increments the port number when the port is occupied.
+     *
+     * @example
+     *
+     * Set the port to a custom value:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   server: {
+     *     port: 3470,
+     *   },
+     * })
+     * ```
+     */
+    port?: number | undefined;
+    /**
+     * When a port is occupied, Rspeedy will automatically increment the port number until an available port is found.
+     *
+     * Set strictPort to true and Rspeedy will throw an exception when the port is occupied.
+     */
+    strictPort?: boolean | undefined;
+}
+
+/**
+ * {@inheritdoc Config.source}
+ *
+ * @public
+ */
+export declare interface Source {
+    /**
+     * Create aliases to `import` or `require` certain modules more easily.
+     *
+     * @example
+     *
+     * A trailing `$` can also be added to the given object's keys to signify an exact match:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     alias: {
+     *       xyz$: 'path/to/file.js',
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * which would yield these results:
+     *
+     * ```js
+     * import Test1 from 'xyz'; // Exact match, so path/to/file.js is resolved and imported
+     * import Test2 from 'xyz/file.js'; // Not an exact match, normal resolution takes place
+     * ```
+     *
+     * @example
+     *
+     * `source.alias` is useful to control how a npm package is resolved.
+     *
+     * - Change `react` to `@lynx-js/react`:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * import { createRequire } from 'module'
+     * const require = createRequire(import.meta.url)
+     * export default defineConfig({
+     *   source: {
+     *     alias: {
+     *       react: require.resolve('@lynx-js/react'),
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * This allows you to use some third-party libraries that directly uses `react` as dependencies in ReactLynx.
+     *
+     * - Force using the same version of `dayjs`:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * import { createRequire } from 'module'
+     * const require = createRequire(import.meta.url)
+     * export default defineConfig({
+     *   source: {
+     *     alias: {
+     *       dayjs: require.resolve('dayjs'),
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * Please note that this is dangerous, since all the `dayjs`(including the dependencies of a dependencies) is resolved to the version in the project.
+     * It may cause both compile-time and runtime errors due to version mismatch.
+     *
+     * @example
+     * Setting `source.alias` to `false` will ignore a module.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     alias: {
+     *       'ignored-module': false,
+     *       './ignored-module': false,
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    alias?: Record<string, string | false | string[]> | undefined;
+    /**
+     * Include additional files that should be treated as static assets. Defaults to be `undefined`.
+     *
+     * @remarks
+     *
+     * By default, Rsbuild treats common image, font, audio, and video files as static assets.
+     * Through the source.assetsInclude config, you can specify additional file types that should be treated as static assets.
+     * These added static assets are processed using the same rules as the built-in supported static assets。
+     *
+     * The usage of `source.assetsInclude` is consistent with {@link https://rspack.dev/config/module#condition | Condition}
+     * in Rspack, which supports passing in strings, regular expressions, arrays of conditions, or logical conditions
+     * to match the module path or assets.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     assetsInclude: /\.json5$/,
+     *   },
+     * })
+     * ```
+     */
+    assetsInclude?: Rspack.RuleSetCondition | undefined;
+    /**
+     * Used to configure the decorators syntax.
+     *
+     * @remarks
+     *
+     * See {@link Decorators.version} for more information.
+     */
+    decorators?: Decorators | undefined;
+    /**
+     * The `define` options is used to define some values or expressions at compile time.
+     *
+     * @example
+     *
+     * Using `define` for environment variables.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     define: {
+     *       BUILD_VERSION: JSON.stringify(process.env.BUILD_VERSION ?? 'unknown_version'),
+     *       'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * Expressions will be replaced with the corresponding code fragments:
+     *
+     * ```js
+     * const version = BUILD_VERSION;
+     * if (process.env.NODE_ENV === 'development') {}
+     *
+     * // ⬇️ Turn into being...
+     * const version = "unknown_version";
+     * if ("development" === 'development') {}
+     * ```
+     *
+     * @example
+     *
+     * Using `define` for `typeof`.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     define: {
+     *       'typeof window': JSON.stringify("undefined"),
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * The `typeof` expressions will be replaced with the corresponding code fragments:
+     *
+     * ```js
+     * if (typeof window !== 'undefined') {}
+     *
+     * // ⬇️ Turn into being...
+     * if ("undefined" !== 'undefined') {}
+     * ```
+     *
+     * @example
+     *
+     * Using `define` with objects.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     define: {
+     *       'import.meta': {
+     *         foo: JSON.stringify('foo'),
+     *         bar: { baz: 0 },
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * Expressions will be replaced with the corresponding code fragments:
+     *
+     * ```js
+     * console.log(import.meta)
+     *
+     * // ⬇️ Turn into being...
+     * console.log({ foo: "foo", bar: { baz: 0 } })
+     * ```
+     *
+     * @remarks
+     *
+     * - If the value provided is a string, it will be utilized as a code fragment.
+     *
+     * - If the value provided is an object, all its keys will be defined in the same manner.
+     *
+     * - If the value isn't a string, it will be stringified, with functions included.
+     *
+     * - Notably, if a `typeof` prefix is attached to the key, it will be exclusively defined for `typeof` calls."
+     */
+    define?: Record<string, string | number | boolean | undefined | Record<string, unknown>> | undefined;
+    /**
+     * The {@link Entry} option is used to set the entry module.
+     *
+     * @remarks
+     *
+     * If no value is provided, the default value `'./src/index.js'` will be used.
+     *
+     * @defaultValue `'./src/index.js'`
+     *
+     * @example
+     *
+     * - Use a single entry:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   entry: './src/pages/main/index.js',
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use a single entry with multiple entry modules:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   entry: ['./src/prefetch.js', './src/pages/main/index.js'],
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use multiple entries(with multiple entry modules):
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   entry: {
+     *     foo: './src/pages/foo/index.js',
+     *     bar: ['./src/pages/bar/index.js', './src/post.js'], // multiple entry modules is allowed
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use multiple entries with {@link EntryDescription}:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   entry: {
+     *     foo: './src/pages/foo/index.js',
+     *     bar: {
+     *       import: ['./src/prefetch.js', './src/pages/bar'],
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    entry?: Entry | undefined;
+    /**
+     * The `source.exclude` is used to specify JavaScript files that should be excluded from compilation.
+     *
+     * @remarks
+     *
+     * By default, Rsbuild compiles JavaScript files in the current directory and TypeScript/JSX files
+     * in all directories. Through the `source.exclude` config, you can specify files or directories
+     * that should be excluded from compilation.
+     * The usage of `source.exclude` is consistent with {@link https://rspack.dev/config/module#ruleexclude | Rule.exclude}
+     * in Rspack, which supports passing in strings or regular expressions to match module paths.
+     *
+     * @example
+     *
+     * - Exclude specific files or directories
+     *
+     * You can exclude specific files or directories from compilation to improve build performance
+     * or avoid processing certain files:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   source: {
+     *     exclude: [
+     *       // Exclude all files in the test directory
+     *       /[\\/]test[\\/]/,
+     *       // Exclude specific file
+     *       './src/legacy-file.js',
+     *       // Exclude files matching a pattern
+     *       /\.stories\.(js|ts)x?$/,
+     *     ],
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Exclude third-party dependencies
+     *
+     * You can exclude specific third-party dependencies that don't need compilation:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * import path from 'node:path'
+     * import { createRequire } from 'node:module'
+     *
+     * const require = createRequire(import.meta.url)
+     *
+     * export default defineConfig({
+     *   source: {
+     *     exclude: [
+     *       // Exclude specific package
+     *       path.dirname(require.resolve('lodash')),
+     *       // Exclude using regex pattern
+     *       /node_modules[\\/]lodash-es[\\/]/,
+     *     ],
+     *   },
+     * })
+     * ```
+     */
+    exclude?: Rspack.RuleSetCondition[] | undefined;
+    /**
+     * The `source.include` is used to specify additional JavaScript files that need to be compiled.
+     *
+     * @remarks
+     *
+     * To avoid redundant compilation, by default, Rsbuild only compiles JavaScript
+     * files in the current directory and TypeScript and JSX files in all directories.
+     * It does not compile JavaScript files under `node_modules`.
+     *
+     * Through the `source.include` config, you can specify directories or modules
+     * that need to be compiled by Rsbuild.
+     * The usage of `source.include` is consistent with {@link https://rspack.dev/config/module#ruleinclude |  Rule.include}
+     * in Rspack, which supports passing in strings or regular expressions to match the module path.
+     *
+     * @example
+     *
+     * - Compile Npm Packages
+     *
+     * A typical usage scenario is to compile npm packages under `node_modules`,
+     * because some third-party dependencies have ESNext syntax, which may not be supported in Lynx.
+     * You can solve the problem by using this config to specify the dependencies
+     * that need to be compiled.
+     *
+     * ```js
+     * import { createRequire } from 'node:module'
+     * import path from 'node:path'
+     *
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * const require = createRequire(import.meta.url)
+     *
+     * export default defineConfig({
+     *   source: {
+     *     include: [
+     *       // Method 1:
+     *       // First get the path of the module by `require.resolve`
+     *       // Then pass path.dirname to point to the corresponding directory
+     *       path.dirname(require.resolve('query-string')),
+     *       // Method 2:
+     *       // Match by regular expression
+     *       // All paths containing `node_modules/query-string/` will be matched
+     *       /node_modules[\\/]query-string[\\/]/,
+     *     ],
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Compile Libraries in Monorepo
+     *
+     * ```js
+     * import path from 'node:path'
+     * import { fileURLToPath } from 'node:url'
+     *
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * const __dirname = path.dirname(fileURLToPath(import.meta.url))
+     *
+     * const packagesDir = path.resolve(__dirname, '../../packages')
+     *
+     * export default defineConfig({
+     *   source: {
+     *     include: [
+     *       // Compile all files in Monorepo's package directory
+     *       // It is recommended to exclude the node_modules
+     *       {
+     *         and: [packagesDir, { not: /[\\/]node_modules[\\/]/ }],
+     *       },
+     *     ],
+     *   },
+     * })
+     * ```
+     */
+    include?: Rspack.RuleSetCondition[] | undefined;
+    /**
+     * The {@link TransformImport} option transforms the import paths to enable modular imports from subpaths of third-party packages, similar to the functionality provided by {@link https://npmjs.com/package/babel-plugin-import | babel-plugin-import}.
+     *
+     * @example
+     *
+     * When using the TUX component library, you can import components on demand with the following config:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   source: {
+     *     transformImport: [
+     *       {
+     *         libraryName: 'foo',
+     *         customName: 'foo/src/components/{{ member }}/{{ member }}',
+     *       },
+     *     ],
+     *   },
+     * })
+     * ```
+     *
+     * This will transform the following source code:
+     *
+     * ```js
+     * import { Button } from 'foo'
+     * ```
+     *
+     * to:
+     *
+     * ```js
+     * import { Button } from 'foo/src/components/Button/Button'
+     * ```
+     */
+    transformImport?: TransformImport[] | undefined;
+    /**
+     * Configure a custom `tsconfig.json` file path to use, can be a relative or absolute path. Defaults to be `./tsconfig.json`.
+     *
+     * @remarks
+     *
+     * The `tsconfigPath` configuration affects the following behaviors:
+     *
+     * - The `paths` field is used to configure {@link Source.alias | Path Aliases}.
+     *
+     * - Sets the scope and rules for the {@link https://rsbuild.dev/plugins/list/plugin-type-check | Type Check Plugin}.
+     *
+     * @example
+     *
+     * Relative path will be resolved relative to the project root directory.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     * export default defineConfig({
+     *   source: {
+     *     tsconfigPath: './tsconfig.build.json',
+     *   },
+     * })
+     * ```
+     */
+    tsconfigPath?: string | undefined;
+}
+
+/**
+ * {@inheritdoc Output.sourceMap}
+ *
+ * @public
+ */
+export declare interface SourceMap {
+    /**
+     * How the source map should be generated. Setting it to `false` will disable the source map.
+     *
+     * @remarks
+     *
+     * Defaults to `'cheap-module-source-map'` at development, `false` at production.
+     *
+     * See {@link https://rspack.dev/config/devtool | Rspack - Devtool} for details.
+     *
+     * @example
+     *
+     * - Enable high-quality source-maps for production:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     sourceMap: {
+     *       js: process.env['NODE_ENV'] === 'production'
+     *         ? 'source-map'
+     *         : 'cheap-module-source-map',
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Disable source-map generation:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     sourceMap: {
+     *       js: false,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * @example
+     *
+     * - Use high-quality source-maps for all environments:
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   output: {
+     *     sourceMap: {
+     *       js: 'source-map',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    js?: Rspack.DevTool | undefined | `${Exclude<Rspack.DevTool, false | 'eval'>}-debugids`;
+}
+
+/**
+ * {@inheritdoc Config.tools}
+ *
+ * @public
+ */
+export declare interface Tools {
+    /**
+     * The {@link Tools.bundlerChain} changes the options of {@link https://www.rspack.dev | Rspack} using {@link https://github.com/rspack-contrib/rspack-chain | rspack-chain}.
+     *
+     * @example
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     bundlerChain(chain) {
+     *       chain.resolve.fullySpecified(true)
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://github.com/rspack-contrib/rspack-chain | rspack-chain} for details.
+     */
+    bundlerChain?: ToolsConfig['bundlerChain'] | undefined;
+    /**
+     * The {@link CssLoader} controls the options of {@link https://github.com/webpack-contrib/css-loader | css-loader}.
+     *
+     * @remarks
+     *
+     * The default option is as follow:
+     *
+     * ```js
+     * const defaultOptions = {
+     *   modules: {
+     *     auto: true,
+     *     namedExport: false,
+     *     exportLocalsConvention: 'camelCase',
+     *     localIdentName: output.cssModules.localIdentName,
+     *   },
+     *   sourceMap: output.sourceMap,
+     *   // importLoaders is `1` when compiling css files, and is `2` when compiling sass/less files
+     *   importLoaders: 1 || 2,
+     * };
+     * ```
+     */
+    cssLoader?: CssLoader | undefined;
+    /**
+     * The {@link CssExtract} controls the options of {@link https://www.rspack.dev/plugins/rspack/css-extract-rspack-plugin | CssExtractRspackPlugin}
+     */
+    cssExtract?: CssExtract | undefined;
+    /**
+     * The {@link Tools.rsdoctor} controls the options of {@link https://rsdoctor.dev/ | Rsdoctor}.
+     *
+     * @example
+     *
+     * - Use the built-in Rsdoctor.
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     rsdoctor: {
+     *       disableClientServer: true,
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://rsdoctor.dev/config/options/options | Rsdoctor - Configuration} for details.
+     */
+    rsdoctor?: RsdoctorRspackPluginOptions | undefined;
+    /**
+     * The {@link Tools.rspack} controls the options of {@link https://www.rspack.dev/ | Rspack}.
+     *
+     * @example
+     *
+     * - Use object config
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     rspack: {
+     *       resolve: {
+     *         fullySpecified: true,
+     *       },
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://www.rspack.dev/config/index | Rspack - Configuration} for details.
+     *
+     * @example
+     *
+     * - Use function with `env` utils
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     rspack(config, { env }) {
+     *       if (env === 'development') {
+     *         config.devtool = 'cheap-source-map'
+     *       }
+     *       return config
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://rsbuild.dev/config/tools/rspack#env | Rsbuild - tools.rspack} for details.
+     *
+     * @example
+     *
+     * - Use function with `mergeConfig` utils
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     rspack(config, { mergeConfig }) {
+     *       return mergeConfig(config, {
+     *         resolve: {
+     *           fullySpecified: true,
+     *         },
+     *       })
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://rsbuild.dev/config/tools/rspack#mergeconfig | Rsbuild - tools.rspack} for details.
+     *
+     * @example
+     *
+     * - Use function with `appendPlugins` utils
+     *
+     * ```js
+     * import { defineConfig } from '@lynx-js/rspeedy'
+     *
+     * export default defineConfig({
+     *   tools: {
+     *     rspack(config, { appendPlugins, rspack }) {
+     *       appendPlugins(new rspack.BannerPlugin({ banner: 'Hello, World!' }))
+     *       return config
+     *     },
+     *   },
+     * })
+     * ```
+     *
+     * See {@link https://rsbuild.dev/config/tools/rspack#appendplugins | Rsbuild - tools.rspack} for details.
+     */
+    rspack?: ToolsConfig['rspack'] | undefined;
+    /**
+     * The {@link Tools.swc} controls the options of {@link https://rspack.dev/guide/features/builtin-swc-loader | builtin:swc-loader}.
+     */
+    swc?: ToolsConfig['swc'] | undefined;
+}
+
+/**
+ * {@inheritdoc Source.transformImport}
+ *
+ * @public
+ */
+export declare interface TransformImport {
+    /**
+     * Whether to convert camelCase imports to kebab-case.
+     *
+     * @example
+     *
+     * - Input:
+     *
+     * ```js
+     * import { ButtonGroup } from 'foo'
+     * ```
+     *
+     * - Output:
+     *
+     * When set to `true`:
+     * ```js
+     * import ButtonGroup from 'foo/button-group'
+     * ```
+     *
+     * When set to `false` or `undefined`:
+     * ```js
+     * import ButtonGroup from 'foo/ButtonGroup'
+     * ```
+     */
+    camelToDashComponentName?: boolean | undefined;
+    /**
+     * Customize the transformed path.
+     *
+     * @remarks
+     *
+     * You you can specify the format of the transformed path.
+     * For example, by setting it to `my-lib/{{ camelCase member }}`, you can convert the member into camelCase.
+     *
+     * The following formats are supported:
+     *
+     * - `kebabCase`: lowercase letters, words joined by hyphens. For example: `my-variable-name`.
+     *
+     * - `snakeCase`: lowercase letters, words joined by underscores. For example: `my_variable_name`.
+     *
+     * - `camelCase`: first letter lowercase, the first letter of each following word uppercase. For example: `myVariableName`.
+     *
+     * - `upperCase`: uppercase letters, other characters unchanged. For example: `MY-VARIABLE-NAME`.
+     *
+     * - `lowerCase`: lowercase letters, other characters unchanged. For example: `my-variable-name`.
+     */
+    customName?: string | undefined;
+    /**
+     * The original import path that needs to be transformed.
+     *
+     * @remarks
+     *
+     * This option is required.
+     */
+    libraryName: string;
+    /**
+     * Used to splice the transformed path, the splicing rule is `${libraryName}/${libraryDirectory}/${member}`, where member is the imported member.
+     *
+     * @remarks
+     *
+     * The default value is `'lib'`.
+     *
+     * @example
+     *
+     * - Input:
+     *
+     * ```js
+     * import { Button } from 'foo'
+     * ```
+     *
+     * - Output:
+     *
+     * ```js
+     * import Button from 'foo/lib/button'
+     * ```
+     */
+    libraryDirectory?: string | undefined;
+    /**
+     * Whether to convert import statements to default imports.
+     *
+     * @example
+     *
+     * - Input:
+     *
+     * ```js
+     * import { Button } from 'foo'
+     * ```
+     *
+     * - Output:
+     *
+     * When set to `true`:
+     * ```js
+     * import Button from 'foo/button'
+     * ```
+     *
+     * When set to `false` or `undefined`:
+     * ```js
+     * import { Button } from 'foo/button'
+     * ```
+     */
+    transformToDefaultImport?: boolean | undefined;
+}
+
+export declare const version: string;
+
+export { }