import type webpack from 'webpack';
import type { CopyFilesOptions } from '../index.js';
import type RuntimeConfig from './config/RuntimeConfig.js';
import type { OptionsCallback } from './utils/apply-options-callback.js';
export type MinimizerPluginOptions = import('minimizer-webpack-plugin').BasePluginOptions & import('minimizer-webpack-plugin').DefinedDefaultMinimizerAndOptions<import('minimizer-webpack-plugin').CustomOptions>;
export type MinimizerOptionsCallback = (this: MinimizerPluginOptions, options: MinimizerPluginOptions, MinimizerPlugin: typeof import('minimizer-webpack-plugin')) => MinimizerPluginOptions | void;
export type FriendlyErrorsPluginOptions = import('@kocal/friendly-errors-webpack-plugin').FriendlyErrorsWebpackPluginOptions;
export type ManifestPluginOptions = import('webpack-manifest-plugin').ManifestPluginOptions;
export type SplitChunksOptions = Exclude<NonNullable<import('webpack').Configuration['optimization']>['splitChunks'], false | undefined>;
export type DevServerOptions = import('webpack-dev-server').Configuration;
export type BabelOptions = import('@babel/core').InputOptions;
export type BabelPresetEnvOptions = import('@babel/preset-env').Options;
export type BabelPresetReactOptions = import('@babel/preset-react').Options;
export type BabelPresetTypeScriptOptions = Parameters<typeof import('@babel/preset-typescript').default>[1];
export type ForkedTypeScriptTypesCheckOptions = Exclude<ConstructorParameters<typeof import('fork-ts-checker-webpack-plugin')>[0], undefined>;
export type VueLoaderOptions = import('vue-loader').VueLoaderOptions;
export type WebpackNotifierOptions = import('webpack-notifier').Options;
export type TsLoaderOptions = Partial<import('ts-loader').Options>;
/**
 * Options for the css-loader (Encore dependency: `css-loader ^7.1.0`).
 *
 * @see https://github.com/webpack-contrib/css-loader#options
 */
export interface CssLoaderOptions {
    url?: boolean | object;
    import?: boolean | object;
    modules?: boolean | 'local' | 'global' | 'pure' | 'icss' | object;
    sourceMap?: boolean;
    importLoaders?: number;
    esModule?: boolean;
    exportType?: 'array' | 'string' | 'css-style-sheet';
    [key: string]: unknown;
}
/**
 * Options for the style-loader (Encore dependency: `style-loader ^4.0.0`).
 *
 * @see https://github.com/webpack-contrib/style-loader#options
 */
export interface StyleLoaderOptions {
    injectType?: 'styleTag' | 'singletonStyleTag' | 'autoStyleTag' | 'lazyStyleTag' | 'lazySingletonStyleTag' | 'lazyAutoStyleTag' | 'linkTag';
    attributes?: Record<string, string>;
    insert?: string | ((...args: any[]) => void);
    styleTagTransform?: string | ((...args: any[]) => void);
    base?: number;
    esModule?: boolean;
    [key: string]: unknown;
}
/**
 * Options for the sass-loader (Encore optional peer: `sass-loader ^16.0.1 || ^17.0.0`).
 *
 * @see https://github.com/webpack-contrib/sass-loader#options
 */
export interface SassLoaderOptions {
    implementation?: unknown;
    /**
     * Options passed to the sass implementation. Loosely typed because sass-loader
     * accepts both the modern and the legacy sass API shapes depending on `api`.
     *
     * @see https://github.com/webpack-contrib/sass-loader#sassoptions
     */
    sassOptions?: Record<string, unknown>;
    sourceMap?: boolean;
    additionalData?: string | ((...args: any[]) => string);
    webpackImporter?: boolean;
    warnRuleAsWarning?: boolean;
    api?: 'legacy' | 'modern' | 'modern-compiler';
    [key: string]: unknown;
}
/**
 * Options for the less-loader (Encore optional peer: `less-loader ^12.2.0`).
 *
 * @see https://github.com/webpack-contrib/less-loader#options
 */
export interface LessLoaderOptions {
    lessOptions?: Record<string, unknown>;
    additionalData?: string | ((...args: any[]) => string);
    sourceMap?: boolean;
    webpackImporter?: boolean;
    implementation?: unknown;
    lessLogAsWarnOrErr?: boolean;
    [key: string]: unknown;
}
/**
 * Options for the stylus-loader (Encore optional peer: `stylus-loader ^8.1.0`).
 *
 * @see https://github.com/webpack-contrib/stylus-loader#options
 */
export interface StylusLoaderOptions {
    stylusOptions?: Record<string, unknown>;
    sourceMap?: boolean;
    webpackImporter?: boolean;
    additionalData?: string | ((...args: any[]) => string);
    implementation?: unknown;
    [key: string]: unknown;
}
/**
 * Options for the postcss-loader (Encore optional peer: `postcss-loader ^8.1.1`).
 *
 * @see https://github.com/webpack-contrib/postcss-loader#options
 */
export interface PostCssLoaderOptions {
    execute?: boolean;
    postcssOptions?: Record<string, unknown> | ((...args: any[]) => Record<string, unknown>);
    sourceMap?: boolean;
    implementation?: unknown;
    [key: string]: unknown;
}
/**
 * Options for the handlebars-loader (Encore optional peer: `handlebars-loader ^1.7.0`).
 *
 * @see https://github.com/pcardune/handlebars-loader
 */
export interface HandlebarsLoaderOptions {
    helperDirs?: string[];
    partialDirs?: string[];
    knownHelpers?: string[];
    inlineRequires?: RegExp;
    exclude?: RegExp;
    debug?: boolean;
    extensions?: string[];
    rootRelative?: string;
    runtime?: string;
    ignorePartials?: boolean;
    ignoreHelpers?: boolean;
    preventIndent?: boolean;
    compat?: boolean;
    precompileOptions?: Record<string, unknown>;
    [key: string]: unknown;
}
interface AssetRuleOptions {
    filename: string;
    maxSize: number | null;
    type: string;
    enabled: boolean;
}
interface CacheGroupOptions {
    test?: RegExp;
    node_modules?: string[];
    [key: string]: unknown;
}
interface ResolvedCopyFilesConfig {
    from: string;
    pattern: RegExp | string;
    to: string | null;
    includeSubdirectories: boolean;
    context: string | null;
}
declare class WebpackConfig {
    runtimeConfig: RuntimeConfig;
    entries: Map<string, string | string[]>;
    styleEntries: Map<string, string | string[]>;
    plugins: Array<{
        plugin: webpack.WebpackPluginInstance;
        priority: number;
    }>;
    loaders: webpack.RuleSetRule[];
    outputPath: string | null;
    publicPath: string | null;
    manifestKeyPrefix: string | null;
    cacheGroups: Record<string, CacheGroupOptions>;
    providedVariables: Record<string, string>;
    configuredFilenames: {
        js?: string;
        css?: string;
        assets?: string;
    };
    aliases: Record<string, string>;
    externals: webpack.ExternalItem[];
    integrityAlgorithms: string[];
    shouldUseSingleRuntimeChunk: boolean | null;
    shouldSplitEntryChunks: boolean;
    useVersioning: boolean;
    useSourceMaps: boolean;
    cleanupOutput: boolean;
    usePersistentCache: boolean;
    extractCss: boolean;
    usePostCssLoader: boolean;
    useLessLoader: boolean;
    useStylusLoader: boolean;
    useSassLoader: boolean;
    useReact: boolean;
    usePreact: boolean;
    useVueLoader: boolean;
    useTypeScriptLoader: boolean;
    useForkedTypeScriptTypeChecking: boolean;
    useBabelTypeScriptPreset: boolean;
    useWebpackNotifier: boolean;
    useHandlebarsLoader: boolean;
    useSvelte: boolean;
    imageRuleOptions: AssetRuleOptions;
    fontRuleOptions: AssetRuleOptions;
    copyFilesConfigs: ResolvedCopyFilesConfig[];
    sassOptions: {
        resolveUrlLoader: boolean;
        resolveUrlLoaderOptions: object;
    };
    preactOptions: {
        preactCompat: boolean;
    };
    babelOptions: {
        exclude: webpack.RuleSetCondition;
        useBuiltIns: 'usage' | 'entry' | false;
        corejs: number | string | {
            version: string;
            proposals: boolean;
        } | null;
    };
    babelTypeScriptPresetOptions: BabelPresetTypeScriptOptions;
    vueOptions: {
        useJsx: boolean;
        version: number | null;
        runtimeCompilerBuild: boolean | null;
    };
    persistentCacheBuildDependencies: Record<string, string[]>;
    imageRuleCallback: OptionsCallback<webpack.RuleSetRule>;
    fontRuleCallback: OptionsCallback<webpack.RuleSetRule>;
    postCssLoaderOptionsCallback: OptionsCallback<PostCssLoaderOptions>;
    sassLoaderOptionsCallback: OptionsCallback<SassLoaderOptions>;
    lessLoaderOptionsCallback: OptionsCallback<LessLoaderOptions>;
    stylusLoaderOptionsCallback: OptionsCallback<StylusLoaderOptions>;
    babelConfigurationCallback: OptionsCallback<BabelOptions>;
    babelPresetEnvOptionsCallback: OptionsCallback<BabelPresetEnvOptions>;
    babelReactPresetOptionsCallback: OptionsCallback<BabelPresetReactOptions>;
    cssLoaderConfigurationCallback: OptionsCallback<CssLoaderOptions>;
    styleLoaderConfigurationCallback: OptionsCallback<StyleLoaderOptions>;
    splitChunksConfigurationCallback: OptionsCallback<SplitChunksOptions>;
    devServerOptionsConfigurationCallback: OptionsCallback<DevServerOptions>;
    vueLoaderOptionsCallback: OptionsCallback<VueLoaderOptions>;
    tsConfigurationCallback: OptionsCallback<TsLoaderOptions>;
    handlebarsConfigurationCallback: OptionsCallback<HandlebarsLoaderOptions>;
    forkedTypeScriptTypesCheckOptionsCallback: OptionsCallback<ForkedTypeScriptTypesCheckOptions>;
    friendlyErrorsPluginOptionsCallback: OptionsCallback<FriendlyErrorsPluginOptions>;
    manifestPluginOptionsCallback: OptionsCallback<ManifestPluginOptions>;
    notifierPluginOptionsCallback: OptionsCallback<WebpackNotifierOptions>;
    watchOptionsConfigurationCallback: OptionsCallback<Exclude<webpack.Configuration['watchOptions'], undefined>>;
    miniCssExtractLoaderConfigurationCallback: OptionsCallback<import('mini-css-extract-plugin').LoaderOptions>;
    miniCssExtractPluginConfigurationCallback: OptionsCallback<import('mini-css-extract-plugin').PluginOptions>;
    loaderConfigurationCallbacks: Record<string, OptionsCallback<webpack.RuleSetRule>>;
    cleanOptionsCallback: OptionsCallback<Exclude<ConstructorParameters<typeof webpack.CleanPlugin>[0], undefined>>;
    definePluginOptionsCallback: OptionsCallback<ConstructorParameters<typeof webpack.DefinePlugin>[0]>;
    minimizerPluginJsOptionsCallback: OptionsCallback<MinimizerPluginOptions>;
    minimizerPluginCssOptionsCallback: OptionsCallback<MinimizerPluginOptions>;
    cssMinimizerExplicitlyConfigured: boolean;
    persistentCacheCallback: OptionsCallback<webpack.FileCacheOptions>;
    _babelRcFileExists?: boolean;
    _babelConfigureOptions?: object;
    _configureBabelCalled: boolean;
    _configureBabelPresetEnvCalled: boolean;
    constructor(runtimeConfig: RuntimeConfig | null);
    getContext(): string;
    /**
     * Lazily detects whether a Babel RC config file exists.
     * If runtimeConfig.babelRcFileExists was explicitly set (not null),
     * that value is used directly. Otherwise, uses
     * babel.loadPartialConfigAsync() and caches the result.
     */
    doesBabelRcFileExist(): Promise<boolean>;
    setOutputPath(outputPath: string): void;
    setPublicPath(publicPath: string): void;
    setManifestKeyPrefix(manifestKeyPrefix: string): void;
    configureDefinePlugin(definePluginOptionsCallback?: OptionsCallback<ConstructorParameters<typeof webpack.DefinePlugin>[0]>): void;
    configureFriendlyErrorsPlugin(friendlyErrorsPluginOptionsCallback?: OptionsCallback<FriendlyErrorsPluginOptions>): void;
    configureManifestPlugin(manifestPluginOptionsCallback?: OptionsCallback<ManifestPluginOptions>): void;
    /**
     * Configures the options passed to the minimizer-webpack-plugin for JS minimization.
     */
    configureJsMinimizerPlugin(jsOptionsCallback?: MinimizerOptionsCallback): void;
    /**
     * Configures the options passed to the minimizer-webpack-plugin for CSS minimization.
     */
    configureCssMinimizerPlugin(cssMinimizerPluginOptionsCallback?: MinimizerOptionsCallback): void;
    /**
     * Returns the value that should be used as the publicPath,
     * which can be overridden by enabling the webpackDevServer
     */
    getRealPublicPath(): string;
    addEntry(name: string, src: string | string[]): void;
    /**
     * Provide a has of entries at once, as an alternative to calling `addEntry` several times.
     */
    addEntries(entries?: Record<string, string | string[]>): void;
    addStyleEntry(name: string, src: string | string[]): void;
    addPlugin(plugin: webpack.WebpackPluginInstance, priority?: number): void;
    addLoader(loader: webpack.RuleSetRule): void;
    addAliases(aliases?: Record<string, string>): void;
    addExternals(externals?: webpack.ExternalItem | webpack.ExternalItem[]): void;
    enableVersioning(enabled?: boolean): void;
    enableSourceMaps(enabled?: boolean): void;
    configureBabel(callback: OptionsCallback<BabelOptions> | null, options?: {
        exclude?: webpack.RuleSetCondition;
        includeNodeModules?: string[];
        useBuiltIns?: 'usage' | 'entry' | false;
        corejs?: number | string | {
            version: string;
            proposals: boolean;
        } | null;
    }): void;
    configureBabelPresetEnv(callback: OptionsCallback<BabelPresetEnvOptions>): void;
    configureCssLoader(callback: OptionsCallback<CssLoaderOptions>): void;
    configureStyleLoader(callback: OptionsCallback<StyleLoaderOptions>): void;
    configureMiniCssExtractPlugin(loaderOptionsCallback: OptionsCallback<import('mini-css-extract-plugin').LoaderOptions>, pluginOptionsCallback?: OptionsCallback<import('mini-css-extract-plugin').PluginOptions>): void;
    enableSingleRuntimeChunk(): void;
    disableSingleRuntimeChunk(): void;
    splitEntryChunks(): void;
    configureSplitChunks(callback: OptionsCallback<SplitChunksOptions>): void;
    configureWatchOptions(callback: OptionsCallback<Exclude<webpack.Configuration['watchOptions'], undefined>>): void;
    configureDevServerOptions(callback: OptionsCallback<DevServerOptions>): void;
    addCacheGroup(name: string, options: CacheGroupOptions): void;
    copyFiles(configs?: CopyFilesOptions | CopyFilesOptions[]): void;
    enablePostCssLoader(postCssLoaderOptionsCallback?: OptionsCallback<PostCssLoaderOptions>): void;
    enableSassLoader(sassLoaderOptionsCallback?: OptionsCallback<SassLoaderOptions>, options?: {
        resolveUrlLoader?: boolean;
        resolveUrlLoaderOptions?: object;
    }): void;
    enableLessLoader(lessLoaderOptionsCallback?: OptionsCallback<LessLoaderOptions>): void;
    enableStylusLoader(stylusLoaderOptionsCallback?: OptionsCallback<StylusLoaderOptions>): void;
    enableStimulusBridge(controllerJsonPath: string): void;
    enableBuildCache(buildDependencies: Record<string, string[]>, callback?: OptionsCallback<webpack.FileCacheOptions>): void;
    enableReactPreset(callback?: OptionsCallback<BabelPresetReactOptions>): void;
    enablePreactPreset(options?: {
        preactCompat?: boolean;
    }): void;
    enableSvelte(): void;
    enableTypeScriptLoader(callback?: OptionsCallback<TsLoaderOptions>): void;
    enableForkedTypeScriptTypesChecking(forkedTypeScriptTypesCheckOptionsCallback?: OptionsCallback<ForkedTypeScriptTypesCheckOptions>): void;
    enableBabelTypeScriptPreset(options?: BabelPresetTypeScriptOptions): void;
    enableVueLoader(vueLoaderOptionsCallback?: OptionsCallback<VueLoaderOptions>, vueOptions?: {
        useJsx?: boolean;
        version?: number | null;
        runtimeCompilerBuild?: boolean | null;
    }): void;
    enableBuildNotifications(enabled?: boolean, notifierPluginOptionsCallback?: OptionsCallback<WebpackNotifierOptions>): void;
    enableHandlebarsLoader(callback?: OptionsCallback<HandlebarsLoaderOptions>): void;
    disableCssExtraction(disabled?: boolean): void;
    configureFilenames(configuredFilenames?: {
        js?: string;
        css?: string;
        assets?: string;
    }): void;
    configureImageRule(options?: {
        filename?: string;
        maxSize?: number | null;
        type?: string;
        enabled?: boolean;
    }, ruleCallback?: OptionsCallback<webpack.RuleSetRule>): void;
    configureFontRule(options?: {
        filename?: string;
        maxSize?: number | null;
        type?: string;
        enabled?: boolean;
    }, ruleCallback?: OptionsCallback<webpack.RuleSetRule>): void;
    cleanupOutputBeforeBuild(cleanOptionsCallback?: OptionsCallback<Exclude<ConstructorParameters<typeof webpack.CleanPlugin>[0], undefined>>): void;
    autoProvideVariables(variables: Record<string, string>): void;
    autoProvidejQuery(): void;
    configureLoaderRule(name: string, callback: OptionsCallback<webpack.RuleSetRule>): void;
    enableIntegrityHashes(enabled?: boolean, algorithms?: string | string[]): void;
    useDevServer(): boolean;
    isProduction(): boolean;
    isDev(): boolean;
    isDevServer(): boolean;
    validateNameIsNewEntry(name: string): void;
}
export default WebpackConfig;