next/dist/server/config-shared.d.ts

The React Framework

import type { webpack } from 'next/dist/compiled/webpack/webpack';
import type { Header, Redirect, Rewrite } from '../lib/load-custom-routes';
import type { ImageConfig, ImageConfigComplete } from '../shared/lib/image-config';
import type { SubresourceIntegrityAlgorithm } from '../build/webpack/plugins/subresource-integrity-plugin';
import type { WEB_VITALS } from '../shared/lib/utils';
import type { NextParsedUrlQuery } from './request-meta';
import type { SizeLimit } from '../types';
import type { SupportedTestRunners } from '../cli/next-test';
import type { ExperimentalPPRConfig } from './lib/experimental/ppr';
import type { MemoryEvictionMode } from '../build/swc/types';
import type { CacheLife } from './use-cache/cache-life';
/**
 * The `cacheLife` profiles after config normalization. `config.ts` always
 * backfills the `default` profile so that its `stale`, `revalidate`, and
 * `expire` are all defined, which is why `default` is `Required<CacheLife>`
 * here while other profiles may still be partial. Runtime `"use cache"` code
 * can therefore read `cacheLifeProfiles.default` without re-validating it.
 */
export interface ResolvedCacheLifeProfiles {
    default: Required<CacheLife>;
    [profile: string]: CacheLife;
}
/**
 * Resolved form of the prefetchInlining config after normalization in
 * config.ts. User input (true, partial objects) is converted to this shape.
 */
export type PrefetchInliningConfig = false | {
    maxSize: number;
    maxBundleSize: number;
};
export type NextConfigComplete = Required<Omit<NextConfig, 'configFile' | 'cacheLife'>> & {
    images: Required<ImageConfigComplete>;
    typescript: TypeScriptConfig;
    configFile: string | undefined;
    configFileName: string;
    cacheLife: ResolvedCacheLifeProfiles;
    htmlLimitedBots: string | undefined;
    experimental: ExperimentalConfig & {
        prefetchInlining?: PrefetchInliningConfig;
        useCacheTimeout: number;
        instantInsights: {
            validationLevel: ValidationLevel;
        };
        turbopackMemoryEvictionMode: MemoryEvictionMode;
    };
    distDirRoot: string;
    repoRoot: string;
};
export type I18NDomains = readonly DomainLocale[];
export interface I18NConfig {
    defaultLocale: string;
    domains?: I18NDomains;
    localeDetection?: false;
    locales: readonly string[];
}
export interface DomainLocale {
    defaultLocale: string;
    domain: string;
    http?: true;
    locales?: readonly string[];
}
export interface TypeScriptConfig {
    /** Do not run TypeScript during production builds (`next build`). */
    ignoreBuildErrors?: boolean;
    /** Relative path to a custom tsconfig file */
    tsconfigPath?: string;
}
export interface EmotionConfig {
    sourceMap?: boolean;
    autoLabel?: 'dev-only' | 'always' | 'never';
    labelFormat?: string;
    importMap?: {
        [importName: string]: {
            [exportName: string]: {
                canonicalImport?: [string, string];
                styledBaseImport?: [string, string];
            };
        };
    };
}
export interface StyledComponentsConfig {
    /**
     * Enabled by default in development, disabled in production to reduce file size,
     * setting this will override the default for all environments.
     */
    displayName?: boolean;
    topLevelImportPaths?: string[];
    ssr?: boolean;
    fileName?: boolean;
    meaninglessFileNames?: string[];
    minify?: boolean;
    transpileTemplateLiterals?: boolean;
    namespace?: string;
    pure?: boolean;
    cssProp?: boolean;
}
export type JSONValue = string | number | boolean | JSONValue[] | {
    [k: string]: JSONValue;
};
export type TurbopackLoaderOptions = Record<string, JSONValue>;
export type TurbopackLoaderItem = string | {
    loader: string;
    options?: TurbopackLoaderOptions;
};
export type TurbopackLoaderBuiltinCondition = 'browser' | 'foreign' | 'development' | 'production' | 'node' | 'edge-light';
export type TurbopackRuleCondition = {
    all: TurbopackRuleCondition[];
} | {
    any: TurbopackRuleCondition[];
} | {
    not: TurbopackRuleCondition;
} | TurbopackLoaderBuiltinCondition | {
    path?: string | RegExp;
    content?: RegExp;
    query?: string | RegExp;
    contentType?: string | RegExp;
};
/**
 * The module type to use for matched files. This determines how files are
 * processed without requiring a custom loader.
 *
 * - `'asset'` - Emit the file and return its URL (like webpack's `asset/resource`)
 * - `'ecmascript'` - Process as JavaScript module
 * - `'typescript'` - Process as TypeScript module
 * - `'css'` - Process as CSS file
 * - `'css-module'` - Process as CSS module
 * - `'wasm'` - Process as WebAssembly module
 * - `'raw'` - Return raw file contents as a string
 * - `'node'` - Process as native Node.js addon
 * - `'bytes'` - Inline file contents as bytes in JavaScript
 *
 * @see [Module Types](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#module-types)
 */
export type TurbopackModuleType = 'asset' | 'ecmascript' | 'typescript' | 'css' | 'css-module' | 'wasm' | 'raw' | 'node' | 'bytes' | 'text';
export type TurbopackRuleConfigItem = {
    /** Loaders to apply to matched files. */
    loaders?: TurbopackLoaderItem[];
    /** Rename the file extension for loader output (e.g., `'*.js'`). */
    as?: string;
    /** Additional conditions for when this rule applies. */
    condition?: TurbopackRuleCondition;
    /**
     * Set the module type directly without using a loader.
     * @see [Module Types](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#module-types)
     */
    type?: TurbopackModuleType;
};
/**
 * This can be an object representing a single configuration, or a list of
 * loaders and/or rule configuration objects.
 *
 * - A list of loader path strings or objects is the "shorthand" syntax.
 * - A list of rule configuration objects can be useful when each configuration
 *   object has different `condition` fields, but still match the same top-level
 *   path glob.
 */
export type TurbopackRuleConfigCollection = TurbopackRuleConfigItem | (TurbopackLoaderItem | TurbopackRuleConfigItem)[];
export interface TurbopackOptions {
    /**
     * (`next --turbopack` only) A mapping of aliased imports to modules to load in their place.
     *
     * @see [Resolve Alias](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#resolving-aliases)
     */
    resolveAlias?: Record<string, string | string[] | Record<string, string | string[]>>;
    /**
     * (`next --turbopack` only) A list of extensions to resolve when importing files.
     *
     * @see [Resolve Extensions](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#resolving-custom-extensions)
     */
    resolveExtensions?: string[];
    /**
     * (`next --turbopack` only) A list of webpack loaders to apply when running with Turbopack.
     *
     * @see [Turbopack Loaders](https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopack#configuring-webpack-loaders)
     */
    rules?: Record<string, TurbopackRuleConfigCollection>;
    /**
     * This is the repo root usually and only files above this
     * directory can be resolved by turbopack.
     */
    root?: string;
    /**
     * Enables generation of debug IDs in JavaScript bundles and source maps.
     * These debug IDs help with debugging and error tracking by providing stable identifiers.
     *
     * @see https://github.com/tc39/ecma426/blob/main/proposals/debug-id.md TC39 Debug ID Proposal
     */
    debugIds?: boolean;
    /**
     * An array of issue filter rules to ignore specific Turbopack issues.
     * Each rule must have a `path` field (mandatory) and optionally `title`
     * and `description`. String paths are treated as glob patterns. String
     * titles/descriptions are exact matches. RegExp values match anywhere
     * within the string (use `^` and `$` anchors for full-string matching).
     */
    ignoreIssue?: Array<{
        path: string | RegExp;
        title?: string | RegExp;
        description?: string | RegExp;
    }>;
    /**
     * Override the global variable name used for
     * chunk loading. Useful when multiple Turbopack-built apps run on the same
     * page (e.g. horizontal micro-frontends) to avoid `globalThis.TURBOPACK`
     * conflicts.
     *
     * @see https://webpack.js.org/configuration/output/#outputchunkloadingglobal
     */
    chunkLoadingGlobal?: string;
}
export interface WebpackConfigContext {
    /** Next.js root directory */
    dir: string;
    /** Indicates if the compilation will be done in development */
    dev: boolean;
    /** It's `true` for server-side compilation, and `false` for client-side compilation */
    isServer: boolean;
    /**  The build id, used as a unique identifier between builds */
    buildId: string;
    /** The next.config.js merged with default values */
    config: NextConfigComplete;
    /** Default loaders used internally by Next.js */
    defaultLoaders: {
        /** Default babel-loader configuration */
        babel: any;
    };
    /** Number of total Next.js pages */
    totalPages: number;
    /** The webpack configuration */
    webpack: any;
    /** The current server runtime */
    nextRuntime?: 'nodejs' | 'edge';
}
export interface NextJsWebpackConfig {
    (
    /** Existing Webpack config */
    config: any, context: WebpackConfigContext): any;
}
/**
 * Set of options for React Compiler that Next.js currently supports.
 *
 * These options may be changed in breaking ways at any time without notice
 * while support for React Compiler is experimental.
 *
 * @see https://react.dev/reference/react-compiler/configuration
 */
export interface ReactCompilerOptions {
    /**
     * Controls the strategy for determining which functions the React Compiler
     * will optimize.
     *
     * The default is `'infer'`, which uses intelligent heuristics to identify
     * React components and hooks.
     *
     * When using `infer`, Next.js applies its own heuristics before calling
     * `react-compiler`. This improves compilation performance by avoiding extra
     * invocations of Babel and reducing redundant parsing of code.
     *
     * @see https://react.dev/reference/react-compiler/compilationMode
     */
    compilationMode?: 'infer' | 'annotation' | 'all';
    /**
     * Controls how the React Compiler handles errors during compilation.
     *
     * The default is `'none'`, which skips components which cannot be compiled.
     *
     * @see https://react.dev/reference/react-compiler/panicThreshold
     */
    panicThreshold?: 'none' | 'critical_errors' | 'all_errors';
}
export interface IncomingRequestLoggingConfig {
    /**
     * A regular expression array to match incoming requests that should not be logged.
     * You can specify multiple patterns to match incoming requests that should not be logged.
     */
    ignore?: RegExp[];
}
export interface LoggingConfig {
    fetches?: {
        fullUrl?: boolean;
        /**
         * If true, fetch requests that are restored from the HMR cache are logged
         * during an HMR refresh request, i.e. when editing a server component.
         */
        hmrRefreshes?: boolean;
    };
    /**
     * If set to false, incoming request logging is disabled.
     * You can specify a pattern to match incoming requests that should not be logged.
     */
    incomingRequests?: boolean | IncomingRequestLoggingConfig;
    /**
     * If false, Server Function invocation logging is disabled.
     * @default true
     */
    serverFunctions?: boolean;
    /**
     * Forward browser console logs to terminal.
     * - `false`: Disable browser log forwarding
     * - `true`: Forward all browser console output to terminal
     * - `'warn'`: Forward warnings and errors to terminal
     * - `'error'`: Forward only errors to terminal
     */
    browserToTerminal?: boolean | 'error' | 'warn';
}
/**
 * All recognized lightningcss feature names.
 * Individual features map 1:1 to lightningcss `Features` bitflags.
 * Composite names (`selectors`, `media-queries`, `colors`) enable a group of
 * related individual features at once.
 *
 * The name→bitmask mapping is duplicated in:
 * - JS:   `packages/next/src/build/webpack/loaders/lightningcss-loader/src/features.ts`
 * - Rust: `crates/next-core/src/next_config.rs` (`lightningcss_feature_names_to_mask`)
 */
export declare const LIGHTNINGCSS_FEATURE_NAMES: readonly ["nesting", "not-selector-list", "dir-selector", "lang-selector-list", "is-selector", "text-decoration-thickness-percent", "media-interval-syntax", "media-range-syntax", "custom-media-queries", "clamp-function", "color-function", "oklab-colors", "lab-colors", "p3-colors", "hex-alpha-colors", "space-separated-color-notation", "font-family-system-ui", "double-position-gradients", "vendor-prefixes", "logical-properties", "light-dark", "selectors", "media-queries", "colors"];
export type LightningCssFeature = (typeof LIGHTNINGCSS_FEATURE_NAMES)[number];
export interface LightningCssFeatures {
    include?: LightningCssFeature[];
    exclude?: LightningCssFeature[];
}
/**
 * Accepted shapes for `experimental.cssChunking`. See [`ExperimentalConfig.cssChunking`] for the
 * accepted values; use [`resolveCssChunkingMode`] to normalize the value at runtime.
 */
export type CssChunkingConfig = boolean | 'strict' | 'loose' | 'graph' | {
    type: 'strict';
} | {
    type: 'loose';
} | {
    type: 'graph';
    requestCost?: number;
    weightDistribution?: number;
};
/**
 * Normalize any [`CssChunkingConfig`] value to one of the four modes the build pipeline cares
 * about:
 *   - `'off'`  — `false`/`undefined`: do not run a CSS chunking plugin.
 *   - `'loose'` — `true` / `'loose'` / `{ type: 'loose' }`: heuristic-based chunking
 *     (the default).
 *   - `'strict'` — `'strict'` / `{ type: 'strict' }`: webpack-only ordered-chunking plugin.
 *   - `'graph'` — `'graph'` / `{ type: 'graph', … }`: Turbopack-only graph algorithm.
 */
export declare function resolveCssChunkingMode(value: CssChunkingConfig | undefined): 'off' | 'loose' | 'strict' | 'graph';
export interface ExperimentalConfig {
    /**
     * @deprecated Use the top-level `outputHashSalt` option instead.
     */
    outputHashSalt?: string;
    appNewScrollHandler?: boolean;
    /**
     * Shows a persistent "Cold cache" badge in the dev overlay after a load that
     * filled an empty cache while streaming. Off by default while the badge's
     * UI/UX is iterated on; the transient "Rendering (cold cache)" pill is shown
     * regardless of this flag.
     */
    coldCacheBadge?: boolean;
    useSkewCookie?: boolean;
    /** @deprecated use top-level `cacheHandlers` instead */
    cacheHandlers?: NextConfig['cacheHandlers'];
    multiZoneDraftMode?: boolean;
    appNavFailHandling?: boolean;
    prerenderEarlyExit?: boolean;
    linkNoTouchStart?: boolean;
    caseSensitiveRoutes?: boolean;
    /**
     * The origins that are allowed to write the rewritten headers when
     * performing a non-relative rewrite. When undefined, no non-relative
     * rewrites will get the rewrite headers.
     */
    clientParamParsingOrigins?: string[];
    /**
     * Caches subsets of a route, seeded from actual navigations, so subsequent
     * navigations to the same or similar pages can be served instantly. Requires
     * Cache Components.
     */
    cachedNavigations?: boolean;
    dynamicOnHover?: boolean;
    useOffline?: boolean;
    optimisticRouting?: boolean;
    instrumentationClientRouterTransitionEvents?: boolean;
    varyParams?: boolean;
    prefetchInlining?: boolean | {
        maxSize?: number;
        maxBundleSize?: number;
    };
    preloadEntriesOnStart?: boolean;
    clientRouterFilter?: boolean;
    clientRouterFilterRedirects?: boolean;
    /**
     * This config can be used to override the cache behavior for the client router.
     * These values indicate the time, in seconds, that the cache should be considered
     * reusable. When the `prefetch` Link prop is left unspecified, this will use the `dynamic` value.
     * When the `prefetch` Link prop is set to `true`, this will use the `static` value.
     */
    staleTimes?: {
        dynamic?: number;
        /** Must be greater than or equal to 30 seconds, to ensure prefetching is not completely wasteful */
        static?: number;
    };
    /**
     * @deprecated use top-level `cacheLife` instead
     */
    cacheLife?: NextConfig['cacheLife'];
    clientRouterFilterAllowedRate?: number;
    /**
     * @deprecated Use `externalProxyRewritesResolve` instead.
     */
    externalMiddlewareRewritesResolve?: boolean;
    externalProxyRewritesResolve?: boolean;
    /**
     * Exposes the Instant Navigation Testing API in production builds. This
     * API is always available in development mode.
     *
     * The testing API allows e2e tests to control navigation timing, enabling
     * deterministic assertions on prefetched/cached UI before dynamic data
     * streams in.
     *
     * WARNING: This flag is intended for profiling and testing purposes only.
     * Do not enable in user-facing production deployments.
     */
    exposeTestingApiInProductionBuild?: boolean;
    /**
     * Show Request Insights in the dev tools indicator. Request Insights records
     * the local framework spans needed to explain App Router request, render,
     * fetch, and cache behavior without requiring an external OTEL collector.
     */
    requestInsights?: boolean;
    extensionAlias?: Record<string, any>;
    allowedRevalidateHeaderKeys?: string[];
    fetchCacheKeyPrefix?: string;
    imgOptConcurrency?: number | null;
    imgOptOperationCache?: boolean | null;
    imgOptTimeoutInSeconds?: number;
    imgOptMaxInputPixels?: number;
    imgOptSequentialRead?: boolean | null;
    optimisticClientCache?: boolean;
    /**
     * @deprecated use config.expireTime instead
     */
    expireTime?: number;
    /**
     * @deprecated Use `proxyPrefetch` instead.
     */
    middlewarePrefetch?: 'strict' | 'flexible';
    proxyPrefetch?: 'strict' | 'flexible';
    manualClientBasePath?: boolean;
    /**
     * CSS Chunking strategy. Defaults to `true` (loose mode), which guesses dependencies between
     * CSS files to keep ordering of them.
     *
     * - `true` / `'loose'` / `{ type: 'loose' }` — default heuristic-based chunking.
     * - `'strict'` / `{ type: 'strict' }` — preserve correct ordering as much as possible, even
     *   when this leads to many requests. Webpack only.
     * - `false` — disable chunking; emit one chunk per CSS module. Webpack only.
     * - `'graph'` / `{ type: 'graph', requestCost?, weightDistribution? }` — Turbopack only.
     *   Selects a CSS chunking strategy that analyzes the most common style orderings across the
     *   application and produces shared chunks accordingly. Compared to the default mode it
     *   intentionally overships some styles in order to reduce the number of CSS requests per
     *   page. Cost overrides:
     *     - `requestCost` (bytes, default `100000`) — additional cost charged for every CSS
     *       request a chunk group makes. Larger values bias the algorithm toward fewer, larger
     *       shared chunks; smaller values toward more, smaller chunks.
     *     - `weightDistribution` (default `0.1`) — controls how a chunk's cost is distributed across
     *       the chunk groups that load it, via a per-group weight of
     *       `groupSize ^ (-weightDistribution)`. `0` weights every chunk group equally; higher
     *       values give smaller chunk groups more weight, so small pages ship fewer unrelated
     *       styles at the expense of more requests overall.
     */
    cssChunking?: CssChunkingConfig;
    /**
     * Controls whether the development server automatically restarts when its
     * heap usage exceeds the memory threshold. Defaults to `true`.
     */
    devMemoryThresholdRestart?: boolean;
    disablePostcssPresetEnv?: boolean;
    cpus?: number;
    memoryBasedWorkersCount?: boolean;
    proxyTimeout?: number;
    isrFlushToDisk?: boolean;
    workerThreads?: boolean;
    optimizeCss?: boolean | Record<string, unknown>;
    nextScriptWorkers?: boolean;
    scrollRestoration?: boolean;
    externalDir?: boolean;
    disableOptimizedLoading?: boolean;
    /** @deprecated A no-op as of Next 16, size metrics were removed from the build output. */
    gzipSize?: boolean;
    craCompat?: boolean;
    esmExternals?: boolean | 'loose';
    fullySpecified?: boolean;
    urlImports?: NonNullable<webpack.Configuration['experiments']>['buildHttp'];
    swcTraceProfiling?: boolean;
    forceSwcTransforms?: boolean;
    swcPlugins?: Array<[string, Record<string, unknown>]>;
    /**
     * Additional options for SWC's preset-env (`env` configuration).
     * These are merged into the `env` block that Next.js passes to SWC,
     * alongside the browserslist-derived `targets`.
     *
     * See https://swc.rs/docs/configuration/supported-browsers for full details.
     *
     * @example
     * ```js
     * // next.config.js
     * module.exports = {
     *   experimental: {
     *     swcEnvOptions: {
     *       mode: 'usage',
     *       coreJs: '3.38',
     *     },
     *   },
     * }
     * ```
     */
    swcEnvOptions?: {
        /**
         * Polyfill injection mode, matching Babel's `useBuiltIns`.
         * - `'usage'`: Adds specific polyfill imports per file based on actual usage.
         * - `'entry'`: Replaces a single `import 'core-js'` with only the polyfills
         *   needed for the target browsers.
         */
        mode?: 'usage' | 'entry';
        /** The core-js version to use (e.g. `'3.38'`). Required when `mode` is set. */
        coreJs?: string;
        /** Core-js modules or SWC transform passes to skip. */
        skip?: string[];
        /** Core-js modules or SWC transform passes to always include. */
        include?: string[];
        /** Core-js modules or SWC transform passes to always exclude. */
        exclude?: string[];
        /** Enable shipped TC39 proposals. */
        shippedProposals?: boolean;
        /** Force all transforms regardless of targets. */
        forceAllTransforms?: boolean;
        /** Enable debug output for preset-env. */
        debug?: boolean;
        /** Enable loose mode for transforms. */
        loose?: boolean;
    };
    largePageDataBytes?: number;
    /**
     * If set to `false`, webpack won't fall back to polyfill Node.js modules in the browser
     * Full list of old polyfills is accessible here:
     * [webpack/webpack#ModuleNotoundError.js#L13-L42](https://github.com/webpack/webpack/blob/2a0536cf510768111a3a6dceeb14cb79b9f59273/lib/ModuleNotFoundError.js#L13-L42)
     */
    fallbackNodePolyfills?: false;
    sri?: {
        algorithm?: SubresourceIntegrityAlgorithm;
    };
    webVitalsAttribution?: Array<(typeof WEB_VITALS)[number]>;
    /**
     * Automatically apply the "modularizeImports" optimization to imports of the specified packages.
     */
    optimizePackageImports?: string[];
    /**
     * Optimize React APIs for server builds.
     */
    optimizeServerReact?: boolean;
    /**
     * Type-checks props and return values of pages.
     * Requires literal values for segment config (e.g. `export const dynamic = 'force-static' as const`).
     */
    strictRouteTypes?: boolean;
    /**
     * Runs the project-local TypeScript CLI instead of using TypeScript's
     * programmatic API for build-time type checking and config loading.
     */
    useTypeScriptCli?: boolean;
    /**
     * Displays an indicator when a React Transition has no other indicator rendered.
     * This includes displaying an indicator on client-side navigations.
     */
    transitionIndicator?: boolean;
    /**
     * Enables experimental gesture transition APIs for optimistic client
     * navigations. Requires experimental React.
     */
    gestureTransition?: boolean;
    /**
     * Controls Turbopack's memory eviction strategy for development sessions
     *
     * Only effective in dev sessions where
     * `experimental.turbopackFileSystemCacheForDev` is enabled (which it is by default).
     *
     * - `false`: disable eviction.
     * - `'full'`: after every snapshot, drop as much memory as possible.
     * - `'auto'`: evict after a snapshot when we expect to save a lot of memory or the system is under pressure
     *
     * Defaults to `'auto'`
     */
    turbopackMemoryEviction?: false | 'full' | 'auto';
    /**
     * Selects the backend used by Turbopack for Node.js evaluation, e.g. webpack
     * loaders, Babel, or PostCSS.
     *
     * This defaults to `'childProcesses'`, which creates a pool of child node.js
     * processes and communciates with them over sockets.
     *
     * `'workerThreads'` runs the same work in worker threads instead, which should
     * use less memory and CPU. It may become the default in a future version of
     * Next.js.
     */
    turbopackPluginRuntimeStrategy?: 'workerThreads' | 'childProcesses';
    /**
     * Enable minification. Defaults to true in build mode and false in dev mode.
     */
    turbopackMinify?: boolean;
    /**
     * Enable support for `with {type: "bytes"}` for ESM imports.
     */
    turbopackImportTypeBytes?: boolean;
    /**
     * Enable scope hoisting. Defaults to true in build mode. Always disabled in development mode.
     */
    turbopackScopeHoisting?: boolean;
    /**
     * Share the browser runtime across routes in a single `runtime.js` asset and inline the
     * per-route chunk-group bootstrap into the HTML, dropping the per-route runtime. Defaults to
     * false. Only applies to production builds; has no effect in development mode.
     */
    turbopackSharedRuntime?: boolean;
    /**
     * (`next --turbopack` only) These options change the assumptions Turbopack makes when
     * making chunk merging decisions and the raw size thresholds it uses.
     */
    turbopackChunking?: {
        /**
         * This is a number between `0..1`, when higher, we weight the benefits of
         * merging chunks for a signal page load higher. If you don't know a good
         * number for this, your bounce rate is a good approximate for this value.
         */
        firstPageLoadPriority?: number;
        /**
         * Regular expressions matching routes that are often the first page
         * visited and whose client-side bundles should be merged more eagerly to reduce the single-route
         * request cost (e.g. the homepage). This is at the cost of extra requests on other pages.
         */
        priorityRoutes?: RegExp[];
        /**
         * How much more eagerly to merge the client-side bundles of
         * `priorityRoutes` routes, as a multiplier on their single-request probability (default
         * `1.5`). Higher values merge more aggressively for those routes at the cost of extra requests
         * elsewhere.
         */
        priorityBoost?: number;
        /**
         * Estimated cost of an additional request, in bytes (uncompressed
         * and unminfified bytes of code, default is 200 KB), used by the chunker to
         * trade off request count against preventing double-fetching. Uncompressed and unminfified code
         * is approximately 5x the size of compressed and minified code.
         */
        requestCost?: number;
        /**
         * Avoid creating more than one chunk smaller than this size, in bytes. Smaller
         * chunks are merged into bigger ones to avoid that. Defaults to `50000` (50 KB).
         */
        minChunkSize?: number;
        /**
         * Avoid creating more than this number of chunks per chunk group. Chunks are
         * merged into bigger ones to avoid that. Defaults to `40`.
         */
        maxChunkCountPerGroup?: number;
        /**
         * Never merge chunks bigger than this size, in bytes, with other chunks. This keeps code
         * in big chunks from being duplicated across multiple chunks. Defaults to `200000` (200 KB).
         */
        maxMergeChunkSize?: number;
        /**
         * Emit each merged production chunk's constituent component chunks alongside it, so the
         * browser runtime can load only the ones it doesn't already have. Defaults to `false`.
         */
        generateComponentChunks?: boolean;
        /**
         * Minimum size, in bytes, for a component chunk to be emitted on its own when
         * `generateComponentChunks` is enabled. Component chunks smaller than this are folded into a
         * single remainder chunk. Defaults to `20000` (20 KB).
         */
        minComponentChunkSize?: number;
    };
    /**
     * (`next --turbopack` only) A custom URL prefix for Web Worker URLs
     * produced by `new Worker(new URL(..., import.meta.url))` — both the
     * entrypoint URL and the module chunks loaded inside the worker —
     * overriding `assetPrefix` for those URLs.
     *
     * Use this when `assetPrefix` points to a cross-origin CDN: browsers
     * reject cross-origin Worker construction, so the entrypoint must stay
     * same-origin. Module chunks loaded inside the worker are also routed
     * through this prefix because the worker bootstrap requires them to be
     * same-origin with the entrypoint. Mirrors webpack's
     * `output.workerPublicPath`.
     *
     * Like `assetPrefix`, the value is a prefix without a trailing slash and
     * without `/_next` — `/_next/` is appended automatically. An empty
     * string is treated as a literal empty prefix (resulting in same-origin
     * `/_next/...` URLs); only `undefined` falls back to `assetPrefix`.
     *
     * @example
     * ```js
     * // next.config.js
     * module.exports = {
     *   assetPrefix: 'https://cdn.example.com',
     *   experimental: {
     *     turbopackWorkerAssetPrefix: '',
     *   },
     * }
     * ```
     */
    turbopackWorkerAssetPrefix?: string;
    /**
     * Enable nested async chunking for client side assets. Defaults to true in build mode and false in dev mode.
     * This optimization computes all possible paths through dynamic imports in the applications to figure out the modules needed at dynamic imports for every path.
     */
    turbopackClientSideNestedAsyncChunking?: boolean;
    /**
     * Enable nested async chunking for server side assets. Defaults to false in dev and build mode.
     * This optimization computes all possible paths through dynamic imports in the applications to figure out the modules needed at dynamic imports for every path.
     */
    turbopackServerSideNestedAsyncChunking?: boolean;
    /**
     * Enable filesystem cache for the turbopack dev server.
     *
     * Defaults to `true`.
     */
    turbopackFileSystemCacheForDev?: boolean;
    /**
     * Enable filesystem cache for the turbopack build.
     *
     * Defaults to `true`.
     */
    turbopackFileSystemCacheForBuild?: boolean;
    /**
     * When running inside a git worktree, warm-start this worktree's Turbopack
     * filesystem cache by seeding it from the main checkout's cache if the
     * worktree doesn't have one yet. This is best-effort and never fails a build.
     *
     * Defaults to `false`.
     */
    turbopackSeedCacheFromWorktree?: boolean;
    /**
     * Enable source maps. Defaults to true.
     */
    turbopackSourceMaps?: boolean;
    /**
     * Enable extraction of source maps from input files. Defaults to true.
     */
    turbopackInputSourceMaps?: boolean;
    /**
     * Currently in active development. This splits modules into fragments and
     * chunks only import the used fragments of the modules.
     */
    turbopackModuleFragments?: boolean;
    /**
     * Enable removing unused imports for turbopack dev server and build.
     */
    turbopackRemoveUnusedImports?: boolean;
    /**
     * Enable removing unused exports for turbopack dev server and build.
     */
    turbopackRemoveUnusedExports?: boolean;
    /**
     * Enable local analysis to infer side effect free modules. When enabled, Turbopack will
     * analyze module code to determine if it has side effects. This can improve tree shaking
     * and bundle size at the cost of some additional analysis.
     *
     * Defaults to `true`
     */
    turbopackInferModuleSideEffects?: boolean;
    /**
     * Enable tree shaking of unused exports from analyzable CommonJS modules in Turbopack.
     *
     * Defaults to `false`
     */
    turbopackCjsTreeShaking?: boolean;
    /**
     * Set this to `false` to disable the automatic configuration of the babel loader when a Babel
     * configuration file is present. This option is enabled by default.
     *
     * If this is set to `false`, but `reactCompiler` is `true`, the built-in Babel will
     * still be configured, but any Babel configuration files on disk will be ignored. If you wish to
     * use React Compiler with a different manually-configured `babel-loader`, you should disable both
     * this and `reactCompiler`.
     */
    turbopackUseBuiltinBabel?: boolean;
    /**
     * Set this to `false` to disable the automatic configuration of the sass loader. The sass loader
     * configuration is enabled by default.
     */
    turbopackUseBuiltinSass?: boolean;
    /**
     * Enable per-directory PostCSS config resolution for Turbopack. When enabled,
     * Turbopack searches for `postcss.config.js` starting from the CSS file's
     * parent directory first, then falls back to the project root. When disabled
     * (default), the project root is checked first, with the CSS file's directory
     * as a fallback.
     */
    turbopackLocalPostcssConfig?: boolean;
    /**
     * The module ID strategy to use for Turbopack.
     * If not set, the default is `'named'` for development and `'deterministic'`
     * for production.
     */
    turbopackModuleIds?: 'named' | 'deterministic';
    /**
     * Enable server-side Fast Refresh (Hot Module Replacement) during development
     * with Turbopack. When set to `false`, server-side HMR is disabled and a full
     * restart is performed on server file changes.
     *
     * Can also be controlled via the `--no-server-fast-refresh` CLI flag.
     * If both are set, the CLI flag takes precedence.
     *
     * @default true
     */
    turbopackServerFastRefresh?: boolean;
    /**
     * For use with `@next/mdx`. Compile MDX files using the new Rust compiler.
     * @see https://nextjs.org/docs/app/api-reference/next-config-js/mdxRs
     */
    mdxRs?: boolean | {
        development?: boolean;
        jsx?: boolean;
        jsxRuntime?: string;
        jsxImportSource?: string;
        providerImportSource?: string;
        mdxType?: 'gfm' | 'commonmark';
    };
    /**
     * Enable type checking for Link and Router.push, etc.
     * @deprecated Use `typedRoutes` instead — this feature is now stable.
     * @see https://nextjs.org/docs/app/api-reference/config/typescript#statically-typed-links
     */
    typedRoutes?: boolean;
    /**
     * Enable type-checking and autocompletion for environment variables.
     *
     * @default false
     */
    typedEnv?: boolean;
    /**
     * Runs the compilations for server and edge in parallel instead of in serial.
     * This will make builds faster if there is enough server and edge functions
     * in the application at the cost of more memory.
     *
     * NOTE: This option is only valid when the build process can use workers. See
     * the documentation for `webpackBuildWorker` for more details.
     */
    parallelServerCompiles?: boolean;
    /**
     * Runs the logic to collect build traces for the server routes in parallel
     * with other work during the compilation. This will increase the speed of
     * the build at the cost of more memory. This option may incur some additional
     * work compared to if the option was disabled since the work is started
     * before data from the client compilation is available to potentially reduce
     * the amount of code that needs to be traced. Despite that, this may still
     * result in faster builds for some applications.
     *
     * Valid values are:
     * - `true`: Collect the server build traces in parallel.
     * - `false`: Do not collect the server build traces in parallel.
     * - `undefined`: Collect server build traces in parallel only in the `experimental-compile` mode.
     *
     * NOTE: This option is only valid when the build process can use workers. See
     * the documentation for `webpackBuildWorker` for more details.
     */
    parallelServerBuildTraces?: boolean;
    /**
     * Run the Webpack build in a separate process to optimize memory usage during build.
     * Valid values are:
     * - `false`: Disable the Webpack build worker
     * - `true`: Enable the Webpack build worker
     * - `undefined`: Enable the Webpack build worker only if the webpack config is not customized
     */
    webpackBuildWorker?: boolean;
    /**
     * Enables optimizations to reduce memory usage in Webpack. This reduces the max size of the heap
     * but may increase compile times slightly.
     * Valid values are:
     * - `false`: Disable Webpack memory optimizations (default).
     * - `true`: Enables Webpack memory optimizations.
     */
    webpackMemoryOptimizations?: boolean;
    /**
     * The array of the meta tags to the client injected by tracing propagation data.
     */
    clientTraceMetadata?: string[];
    /**
     * @deprecated This configuration option has been merged into `cacheComponents`.
     * The Partial Prerendering feature is still available via `cacheComponents`.
     */
    ppr?: ExperimentalPPRConfig;
    /**
     * Enables experimental taint APIs in React.
     * Using this feature will enable the `react@experimental` for the `app` directory.
     */
    taint?: boolean;
    /**
     * Enables blocking server-side rendering for the `app` directory: React emits
     * a `<link rel="expect">` tag that holds the browser's first paint until the
     * streamed shell is coherent, avoiding the layout shift / flicker that can
     * occur while a partially-streamed HTML document is painted. Note that
     * `rel="expect"` is currently only implemented by Chromium-based browsers.
     *
     * This feature is currently only available in React's experimental release
     * channel, so enabling it opts the `app` directory into `react@experimental`
     * (the same channel used by `taint`, `transitionIndicator`, and
     * `gestureTransition`). The name mirrors React's underlying feature flag.
     *
     * This is an opt-in only. Setting it to `false` does not disable the
     * experimental channel when another feature (such as `taint`,
     * `transitionIndicator`, or `gestureTransition`) requires it.
     */
    blockingSSR?: boolean;
    /**
     * Uninstalls all "unhandledRejection" and "uncaughtException" listeners from
     * the global process so that we can override the behavior, which in some
     * runtimes is to exit the process.
     *
     * This is experimental until we've considered the impact in various
     * deployment environments.
     */
    removeUncaughtErrorAndRejectionListeners?: boolean;
    /**
     * During an RSC request, validates that the request headers match the
     * cache-busting search parameter sent by the client.
     */
    validateRSCRequestHeaders?: boolean;
    serverActions?: {
        /**
         * Allows adjusting body parser size limit for server actions.
         */
        bodySizeLimit?: SizeLimit;
        /**
         * Allowed origins that can bypass Server Action's CSRF check. This is helpful
         * when you have reverse proxy in front of your app.
         * @example
         * ["my-app.com", "*.my-app.com"]
         */
        allowedOrigins?: string[];
    };
    /**
     * Allows adjusting the maximum size of the postponed state body for PPR
     * resume requests. This includes the Resume Data Cache (RDC) which may grow
     * large for some applications.
     * @default '100 MB'
     */
    maxPostponedStateSize?: SizeLimit;
    /**
     * enables the minification of server code.
     */
    serverMinification?: boolean;
    /**
     * Enables source maps generation for the server production bundle.
     */
    serverSourceMaps?: boolean;
    useWasmBinary?: boolean;
    /**
     * Use lightningcss instead of postcss-loader
     */
    useLightningcss?: boolean;
    /**
     * Configure which CSS features lightningcss should always transpile
     * (include) or never transpile (exclude), regardless of browser targets.
     * Requires `useLightningcss: true`.
     */
    lightningCssFeatures?: LightningCssFeatures;
    /**
     * Enables `fetch` requests to be proxied to the experimental test proxy server
     */
    testProxy?: boolean;
    /**
     * Set a default test runner to be used by `next experimental-test`.
     */
    defaultTestRunner?: SupportedTestRunners;
    /**
     * Allow NODE_ENV=development even for `next build`.
     */
    allowDevelopmentBuild?: true;
    /**
     * @deprecated use `config.bundlePagesRouterDependencies` instead
     *
     */
    bundlePagesExternals?: boolean;
    /**
     * @deprecated use `config.serverExternalPackages` instead
     *
     */
    serverComponentsExternalPackages?: string[];
    /**
     * When enabled, in dev mode, Next.js will send React's debug info through the
     * WebSocket connection, instead of including it in the main RSC payload.
     */
    reactDebugChannel?: boolean;
    /**
     * @deprecated use top-level `cacheComponents` instead
     */
    cacheComponents?: boolean;
    /**
     * Configuration for instant navigation validation.
     */
    instantInsights?: {
        /**
         * Controls the validation behavior of Instant Insights
         *
         * - `'warning'` (default): Validates all navigations for Instant UI in development
         * - `'manual-warning'`: Validates navigations for Instant UI in development only when configured with `instant` in Pages and Layouts
         * - `'experimental-error'`: Validates all navigations for Instant in development and build. Use with caution.
         * - `'experimental-manual-error'`: Validates navigations for Instant UI in development and build when configured with `instant` in Pages and Layouts. Use with caution.
         */
        validationLevel?: ValidationLevel;
    };
    /**
     * Runs development Cache Components validation on a worker thread rather than
     * the main thread, keeping the dev server's event loop responsive during
     * rapid navigation. This covers static-shell validation (which runs on
     * initial load and HMR refresh) as well as instant-navigation validation
     * (when `instant` is configured). Enabled by default; set to `false` to run
     * validation in-process, as an escape hatch to isolate a problem or fall back
     * if the worker misbehaves.
     *
     * Has no effect with Webpack, where validation always runs in process. The
     * worker's thread cannot reach Webpack's dev source maps, so validation
     * errors would be reported without a source location.
     */
    devValidationWorker?: boolean;
    /**
     * The number of times to retry static generation (per page) before giving up.
     */
    staticGenerationRetryCount?: number;
    /**
     * The amount of pages to export per worker during static generation.
     */
    staticGenerationMaxConcurrency?: number;
    /**
     * The minimum number of pages to be chunked into each export worker.
     */
    staticGenerationMinPagesPerWorker?: number;
    /**
     * Allows previously fetched data to be re-used when editing server components.
     */
    serverComponentsHmrCache?: boolean;
    /**
     * Cancels the render and validation work for a Server Components HMR refresh
     * once a newer refresh supersedes it. Development only.
     */
    serverComponentsHmrCancellation?: boolean;
    /**
     * Render <style> tags inline in the HTML for imported CSS assets.
     * Supports app-router in production mode only.
     */
    inlineCss?: boolean;
    /**
     * This config allows you to enable the experimental navigation API `forbidden` and `unauthorized`.
     */
    authInterrupts?: boolean;
    /**
     * Seconds before a `'use cache'` fill is considered stalled. Defaults to
     * 90% of `staticPageGenerationTimeout`. In prerender it's clamped to that
     * ceiling so errors surface before the build worker kills the page.
     */
    useCacheTimeout?: number;
    /**
     * Enables the use of the `"use cache"` directive.
     * @deprecated use top-level `cacheComponents` instead
     */
    useCache?: boolean;
    /**
     * Enables durable `"use cache"` remote cache entries across deployments. Only implemented for
     * Turbopack.
     */
    durableUseCacheEntries?: boolean;
    /**
     * Enables detection and reporting of slow modules during development builds.
     * Enabling this may impact build performance to ensure accurate measurements.
     */
    slowModuleDetection?: {
        /**
         * The time threshold in milliseconds for identifying slow modules.
         * Modules taking longer than this build time threshold will be reported.
         */
        buildTimeThresholdMs: number;
    };
    /**
     * Enables using the global-not-found.js file in the app directory
     *
     */
    globalNotFound?: boolean;
    /**
     * @experimental Use the Rust port of the React compiler (Turbopack only).
     * Requires `reactCompiler` to be enabled.
     */
    turbopackRustReactCompiler?: boolean;
    /**
     * Enable debug information to be forwarded from browser to dev server stdout/stderr.
     *
     * - `'warn'` (default): Forward warnings and errors to terminal
     * - `'error'`: Forward only errors to terminal
     * - `'verbose'`: Forward all browser console output to terminal
     * - `true`: Same as 'verbose' - forward all browser console output to terminal
     * - `false`: Disable browser log forwarding to terminal
     * - Object: Enable with custom configuration
     *
     * @deprecated Use `logging.browserToTerminal` instead.
     */
    browserDebugInfoInTerminal?: boolean | 'error' | 'warn' | 'verbose' | {
        /**
         * Minimum log level to show in terminal.
         * @default 'verbose' (for object config, to preserve backward compatibility)
         */
        level?: 'error' | 'warn' | 'verbose';
        /**
         * Option to limit stringification at a specific nesting depth when logging circular objects.
         * @default 5
         */
        depthLimit?: number;
        /**
         * Maximum number of properties/elements to stringify when logging objects/arrays with circular references.
         * @default 100
         */
        edgeLimit?: number;
        /**
         * Whether to include source location information in debug output when available
         */
        showSourceLocation?: boolean;
    };
    /**
     * Body size limit for request bodies with middleware configured.
     * Defaults to 10MB. Can be specified as a number (bytes) or string (e.g. '5mb').
     *
     * @deprecated Use `proxyClientMaxBodySize` instead.
     */
    middlewareClientMaxBodySize?: SizeLimit;
    /**
     * Body size limit for request bodies with proxy configured.
     * Defaults to 10MB. Can be specified as a number (bytes) or string (e.g. '5mb').
     */
    proxyClientMaxBodySize?: SizeLimit;
    /**
     * Enable the Model Context Protocol (MCP) server for AI-assisted development.
     * When enabled, Next.js will expose an MCP server at `/_next/mcp` that provides
     * code intelligence and project context to AI assistants.
     *
     * @default true
     */
    mcpServer?: boolean;
    /**
     * Acquires a lockfile at `<distDir>/lock` when starting `next dev` or `next
     * build`. Failing to acquire the lock causes the process to exit with an
     * error message.
     *
     * This is because if multiple processes write to the same `distDir` at the
     * same time, it can mangle the state of the directory. Disabling this option
     * is not recommended.
     *
     * @default true
     */
    lockDistDir?: boolean;
    /**
     * Hide logs that occur after a render has already aborted.
     * This can help reduce noise in the console when dealing with aborted renders.
     *
     * @default false
     */
    hideLogsAfterAbort?: boolean;
    /**
     * Whether `process.env.NEXT_DEPLOYMENT_ID` is available at runtime in the server (and `next
     * build` doesn't need to embed the deployment ID value into the build output).
     *
     * @default false
     */
    runtimeServerDeploymentId?: boolean;
    /**
     * @deprecated Use the top-level `supportsImmutableAssets` option instead.
     */
    supportsImmutableAssets?: boolean;
    /**
     * An array of paths in app or pages directories that should wait to be processed
     * until all other entries have been processed. This is useful for deferring
     * compilation of certain routes during development and build.
     */
    deferredEntries?: string[];
    /**
     * An async function that is called and awaited before processing deferred entries.
     * This callback runs after all non-deferred entries have been compiled.
     */
    onBeforeDeferredEntries?: () => Promise<void>;
    /**
     * Whether to report inlined system environment variables as warnings or errors.
     * Only supported for Turbopack.
     */
    reportSystemEnvInlining?: 'error' | 'warn';
}
export type ExportPathMap = {
    [path: string]: {
        page: string;
        query?: NextParsedUrlQuery;
    };
};
/**
 * Next.js can be configured through a `next.config.js` file in the root of your project directory.
 *
 * This can change the behavior, enable experimental features, and configure other advanced options.
 *
 * Read more: [Next.js Docs: `next.config.js`](https://nextjs.o