Upgrading next 10 to 11

Unknown10.2.3 → 11.1.4Security3

Full comparison Back to next

SecurityHigh · CVSS 7.5Unexpected server crash in Next.js.GHSA-25mp-g6fv-mqxx · CVE-2021-43803 ↗

UnknownUpgrade verdict

None of the 174 releases in this range publish notes, so breaking changes can't be ruled out.

In plain terms

Some releases in this range publish no notes, so DepDelta can't rule out breaking changes.
DepDelta found no commit log for them either.

Must act 3 items need code or config changes

Node.js requirement changed in 11.1.3: >=10.13.0 → >=12.0.0.

Adds @next/swc-darwin-arm64 11.1.4, @next/swc-darwin-x64 11.1.4, @next/swc-linux-x64-gnu 11.1.4, @next/swc-win32-x64-msvc 11.1.4, @node-rs/helper 1.2.1, image-size 1.0.0.

Drops @opentelemetry/api, prop-types.

Installs 283 packages in all (was 277).

What you must change

Security3

Unexpected server crash in Next.js.

High · CVSS 7.5

11.1.3GitHub AdvisoryOriginalView source

XSS in Image Optimization API for Next.js

High · CVSS 7.5

11.1.1GitHub AdvisoryOriginalView source

Open Redirect in Next.js

Moderate · CVSS 6.9

11.1.0GitHub AdvisoryOriginalView source

API changes

Generated by DepDelta from published .d.ts files. Not mixed with prose notes.

removed: export * from './dist/next-server/lib/amp'
added: export * from './dist/shared/lib/amp'

removed: export * from './dist/next-server/lib/runtime-config'
removed: export { default } from './dist/next-server/lib/runtime-config'
added: export * from './dist/shared/lib/runtime-config'
added: export { default } from './dist/shared/lib/runtime-config'

removed: export * from './dist/next-server/lib/constants'
added: export * from './dist/shared/lib/constants'

added: const content: StaticImageData
added: default content

added: const content: StaticImageData
added: default content

added: const content: StaticImageData
added: default content

added: const content: StaticImageData
added: default content

added: const content: StaticImageData
added: default content

added: const content: StaticImageData
added: default content

added: const content: any
added: default content

added: const content: StaticImageData
added: default content

removed: interface StyleHTMLAttributes<T> extends HTMLAttributes<T>
removed: property StyleHTMLAttributes.global?: boolean
removed: property StyleHTMLAttributes.jsx?: boolean
added: interface ImgHTMLAttributes<T> extends HTMLAttributes<T>
added: property ImgHTMLAttributes.loading?: 'auto' | 'eager' | 'lazy'

changed: default function getConfig(this: NextJsLoaderContext, { source, loaderOptions, target, filename, inputSourceMap }: { source: string; loaderOptions: NextBabelLoaderOptions; target: string; filename: string; inputSourceMap?: object | null }): BabelConfig → default function getConfig(this: NextJsLoaderContext, { source, target, loaderOptions, filename, inputSourceMap }: { source: string; loaderOptions: NextBabelLoaderOptions; target: string; filename: string; inputSourceMap?: object | null }): BabelConfig

removed: property NextBabelLoaderOptions.presets: any[]
changed: property NextJsLoaderContext.currentTraceSpan?: Span → property NextJsLoaderContext.currentTraceSpan: Span

removed: default function NextToNextServer(...args: any): PluginObj
added: default function CommonJSModulePlugin(...args: any): PluginObj

changed: function runCompiler(config: webpack.Configuration | webpack.Configuration[]): Promise<CompilerResult> → function runCompiler(config: webpack.Configuration, { runWebpackSpan }: { runWebpackSpan: Span }): Promise<CompilerResult>

changed: function createEntrypoints(pages: PagesMapping, target: 'server' | 'serverless' | 'experimental-serverless-trace', buildId: string, previewMode: __ApiPreviewProps, config: NextConfig, loadedEnvFiles: LoadedEnvFiles): Entrypoints → function createEntrypoints(pages: PagesMapping, target: 'server' | 'serverless' | 'experimental-serverless-trace', buildId: string, previewMode: __ApiPreviewProps, config: NextConfigComplete, loadedEnvFiles: LoadedEnvFiles): Entrypoints
changed: function createPagesMapping(pagePaths: string[], extensions: string[]): PagesMapping → function createPagesMapping(pagePaths: string[], extensions: string[], isWebpack5: boolean, isDev: boolean): PagesMapping

changed: function generateBuildId(generate: () => string | null, fallback: () => string): Promise<string> → function generateBuildId(generate: () => string | null | Promise<string | null>, fallback: () => string): Promise<string>

changed: default function build(dir: string, conf?: null, reactProductionProfiling?: boolean, debugOutput?: boolean): Promise<void> → default function build(dir: string, conf?: null, reactProductionProfiling?: boolean, debugOutput?: boolean, runLint?: boolean): Promise<void>

changed: function isPageStatic(page: string, distDir: string, serverless: boolean, runtimeEnvConfig: any, locales?: string[], defaultLocale?: string, parentId?: any): Promise<{ isStatic?: boolean; isAmpOnly?: boolean; isHybridAmp?: boolean; hasServerProps?: boolean; hasStaticProps?: boolean; prerenderRoutes?: string[]; encodedPrerenderRoutes?: string[]; prerenderFallback?: boolean | 'blocking'; isNextImag… → function isPageStatic(page: string, distDir: string, serverless: boolean, runtimeEnvConfig: any, httpAgentOptions: NextConfigComplete['httpAgentOptions'], locales?: string[], defaultLocale?: string, parentId?: any): Promise<{ isStatic?: boolean; isAmpOnly?: boolean; isHybridAmp?: boolean; hasServerProps?: boolean; hasStaticProps?: boolean; prerenderRoutes?: string[]; encodedPrerenderRoutes?: stri…
added: property PageInfo.pageDuration: number | undefined
added: property PageInfo.ssgPageDurations: number[] | undefined

changed: default function getBaseWebpackConfig(dir: string, { buildId, config, dev, isServer, pagesDir, target, reactProductionProfiling, entrypoints, rewrites, isDevFallback }: { buildId: string; config: NextConfig; dev?: boolean; isServer?: boolean; pagesDir: string; target?: string; reactProductionProfiling?: boolean; entrypoints: WebpackEntrypoints; rewrites: CustomRoutes['rewrites']; isDevFallback?: boolean… → default function getBaseWebpackConfig(dir: string, { buildId, config, dev, isServer, pagesDir, target, reactProductionProfiling, entrypoints, rewrites, isDevFallback, runWebpackSpan }: { buildId: string; config: NextConfigComplete; dev?: boolean; isServer?: boolean; pagesDir: string; target?: string; reactProductionProfiling?: boolean; entrypoints: WebpackEntrypoints; rewrites: CustomRoutes['rewrites'];…

added: const regexLikeCss: RegExp

changed: function getGlobalImportError(file: string | null): string → function getGlobalImportError(): string

changed: function build(config: webpack.Configuration, { rootDirectory, customAppFile, isDevelopment, isServer, assetPrefix, sassOptions, productionBrowserSourceMaps, future }: { rootDirectory: string; customAppFile: string | null; isDevelopment: boolean; isServer: boolean; assetPrefix: string; sassOptions: any; productionBrowserSourceMaps: boolean; future: NextConfig['future'] }): Promise<webpack.Configu… → function build(config: webpack.Configuration, { rootDirectory, customAppFile, isDevelopment, isServer, assetPrefix, sassOptions, productionBrowserSourceMaps, future, isCraCompat }: { rootDirectory: string; customAppFile: RegExp; isDevelopment: boolean; isServer: boolean; assetPrefix: string; sassOptions: any; productionBrowserSourceMaps: boolean; future: NextConfigComplete['future']; isCraCompat?…

changed: type ConfigurationContext = { rootDirectory: string; customAppFile: string | null; isDevelopment: boolean; isProduction: boolean; isServer: boolean; isClient: boolean; assetPrefix: string… → type ConfigurationContext = { rootDirectory: string; customAppFile: RegExp; isDevelopment: boolean; isProduction: boolean; isServer: boolean; isClient: boolean; assetPrefix: string; sassO…

changed: function getPageHandler(ctx: ServerlessHandlerCtx): { renderReqToHTML: (req: IncomingMessage, res: ServerResponse, renderMode?: true | 'export' | 'passthrough' | undefined, _renderOpts?: any, _params?: any) => Promise<string | { html: string | null; renderOpts: any } | null>; render: (req: IncomingMessage, res: ServerResponse) => Promise<void> } → function getPageHandler(ctx: ServerlessHandlerCtx): { renderReqToHTML: (req: IncomingMessage, res: ServerResponse, renderMode?: true | 'export' | 'passthrough' | undefined, _renderOpts?: any, _params?: any) => Promise<string | { html: import('../../../../server/utils').RenderResult | null; renderOpts: any } | null>; render: (req: IncomingMessage, res: ServerResponse) => Promise<void> }

added: class CopyFilePlugin
added: constructor CopyFilePlugin({ filePath, cacheKey, name, info }: { filePath: string; cacheKey: string; name: string; minimize: boolean; info?: object })
added: method CopyFilePlugin.apply(compiler: webpack.Compiler): void

added: class TraceEntryPointsPlugin implements webpack.Plugin
added: constructor TraceEntryPointsPlugin({ appDir, excludeFiles }: { appDir: string; excludeFiles?: string[] })
added: method TraceEntryPointsPlugin.apply(compiler: webpack.Compiler): void
added: method TraceEntryPointsPlugin.createTraceAssets(compilation: any, assets: any): void

removed: method ProfilingPlugin.traceLoopedHook(spanName: string, startHook: any, stopHook: any): void
changed: method ProfilingPlugin.traceHookPair(spanName: string, startHook: any, stopHook: any, attrs?: any, onSetSpan?: (span: Span) => void): void → method ProfilingPlugin.traceHookPair(spanName: string, startHook: any, stopHook: any, { parentSpan, attrs, onSetSpan }?: { parentSpan?: () => Span; attrs?: any; onSetSpan?: (span: Span) => void }): void
added: constructor ProfilingPlugin({ runWebpackSpan }: { runWebpackSpan: Span })
added: property ProfilingPlugin.runWebpackSpan: Span

added: export * from './utils'
added: export { default as exportPage } from '../export/worker'

added: const nextLint: cliCommand

removed: default Script
removed: function Script(props: Props): JSX.Element | null
removed: function initScriptLoader(scriptLoaderItems: Props[]): void
removed: interface Props extends ScriptHTMLAttributes<HTMLScriptElement>
removed: property Props.children?: React.ReactNode
removed: property Props.id?: string
removed: property Props.onError?: () => void
removed: property Props.onLoad?: () => void
removed: property Props.strategy?: 'afterInteractive' | 'lazyOnload' | 'beforeInteractive'

changed: default function Image({ src, sizes, unoptimized, priority, loading, className, quality, width, height, objectFit, objectPosition, loader, placeholder, blurDataURL, ...all }: ImageProps): JSX.Element → default function Image({ src, sizes, unoptimized, priority, loading, lazyBoundary, className, quality, width, height, objectFit, objectPosition, onLoadingComplete, loader, placeholder, blurDataURL, ...all }: ImageProps): JSX.Element
changed: type ImageProps = Omit<JSX.IntrinsicElements['img'], 'src' | 'srcSet' | 'ref' | 'width' | 'height' | 'loading' | 'style'> & { src: string; loader?: ImageLoader; quality?: number… → type ImageProps = Omit<JSX.IntrinsicElements['img'], 'src' | 'srcSet' | 'ref' | 'width' | 'height' | 'loading' | 'style'> & { src: string | StaticImport; width?: number | string…

removed: const _default: (opts?: { webpackHMR?: any }) => Promise<MittEmitter | { emitter: MittEmitter; render: typeof render; renderCtx: Pick<import('../next-server/lib/router/router'…
removed: default _default
changed: const emitter: MittEmitter → const emitter: MittEmitter<string>
added: function initNext(opts?: { webpackHMR?: any }): Promise<MittEmitter<string> | { emitter: MittEmitter<string>; renderCtx: Omit<import('../shared/lib/router/router').CompletePrivateRouteInfo, 'styleSheets'> & { initial: true } & { App: AppComponent; scroll?: { x: number; y: number } | null | undefined } }>

changed: function Link(props: React.PropsWithChildren<LinkProps>): React.DetailedReactHTMLElement<{ onMouseEnter?: ((event: React.MouseEvent<Element, MouseEvent>) => void) | undefined; onClick: (event: React.MouseEvent<Element, MouseEvent>) => void; href?: string | undefined; ref?: any }, HTMLElement> → function Link(props: React.PropsWithChildren<LinkProps>): React.DetailedReactHTMLElement<{ onMouseEnter?: React.MouseEventHandler<Element> | undefined; onClick: React.MouseEventHandler; href?: string | undefined; ref?: any }, HTMLElement>

changed: const cancelIdleCallback: (id: any) => void → const cancelIdleCallback: (id: RequestIdleCallbackHandle) => void
changed: const requestIdleCallback: (callback: (deadline: RequestIdleCallbackDeadline) => void, opts?: RequestIdleCallbackOptions | undefined) => any → const requestIdleCallback: (callback: (deadline: RequestIdleCallbackDeadline) => void, opts?: RequestIdleCallbackOptions | undefined) => RequestIdleCallbackHandle

removed: default createRouteLoader

removed: const createRouter: (pathname: string, query: import('querystring').ParsedUrlQuery, as: string, __3: { subscription: (data: import('../next-server/lib/router/router').PrivateRoute…
added: function createRouter(...args: RouterArgs): Router
added: type RouterEvent = typeof routerEvents[number]

added: default Script
added: function Script(props: ScriptProps): JSX.Element | null
added: function initScriptLoader(scriptLoaderItems: ScriptProps[]): void
added: interface ScriptProps extends ScriptHTMLAttributes<HTMLScriptElement>
added: property ScriptProps.children?: React.ReactNode
added: property ScriptProps.id?: string
added: property ScriptProps.onError?: (e: any) => void
added: property ScriptProps.onLoad?: (e: any) => void
added: property ScriptProps.strategy?: 'afterInteractive' | 'lazyOnload' | 'beforeInteractive'
added: type Props = ScriptProps

changed: default function exportApp(dir: string, options: ExportOptions, configuration?: NextConfig): Promise<void> → default function exportApp(dir: string, options: ExportOptions, configuration?: NextConfigComplete): Promise<void>

changed: default function exportPage({ parentSpanId, path, pathMap, distDir, outDir, pagesDataDir, renderOpts, buildExport, serverRuntimeConfig, subFolders, serverless, optimizeFonts, optimizeImages, optimizeCss, disableOptimizedLoading }: ExportPageInput): Promise<ExportPageResults> → default function exportPage({ parentSpanId, path, pathMap, distDir, outDir, pagesDataDir, renderOpts, buildExport, serverRuntimeConfig, subFolders, serverless, optimizeFonts, optimizeImages, optimizeCss, disableOptimizedLoading, httpAgentOptions }: ExportPageInput): Promise<ExportPageResults>

added: const ESLINT_DEFAULT_DIRS: string[]
added: const ESLINT_PROMPT_VALUES: ({ title: string; recommended: boolean; config: { extends: string } } | { title: string; config: { extends: string }; recommended?: undefined } | { title: stri…

changed: function formatResults(baseDir: string, results: LintResult[]): string → function formatResults(baseDir: string, results: LintResult[], format: (r: LintResult[]) => string): { output: string; totalNextPluginErrorCount: number; totalNextPluginWarningCount: number }
added: interface LintResult
added: property LintResult.errorCount: number
added: property LintResult.filePath: string
added: property LintResult.messages: LintMessage[]
added: property LintResult.output?: string
added: property LintResult.source?: string
added: property LintResult.warningCount: number

removed: function getLintIntent(eslintrcFile: string | null, pkgJsonEslintConfig: string | null): Promise<LintIntent | false>
removed: type LintIntent = { firstTimeSetup: boolean }

added: function hasEslintConfiguration(eslintrcFile: string | null, packageJsonConfig: { eslintConfig: any } | null): Promise<ConfigAvailable>
added: type ConfigAvailable = { exists: boolean; emptyEslintrc?: boolean; emptyPkgJsonConfig?: boolean; firstTimeSetup?: true }

changed: function runLintCheck(baseDir: string, pagesDir: string): Promise<string | null> → function runLintCheck(baseDir: string, lintDirs: string[], lintDuringBuild?: boolean, eslintOptions?: any, reportErrorsOnly?: boolean, maxWarnings?: number, formatter?: string | null, strict?: boolean): ReturnType<typeof lint>

changed: function writeDefaultConfig(eslintrcFile: string | null, pkgJsonPath: string | null): Promise<void> → function writeDefaultConfig(baseDir: string, { exists, emptyEslintrc, emptyPkgJsonConfig }: ConfigAvailable, selectedConfig: any, eslintrcFile: string | null, pkgJsonPath: string | null, packageJsonConfig: { eslintConfig: any } | null): Promise<void>

changed: function hasNecessaryDependencies(baseDir: string, checkTSDeps: boolean, checkESLintDeps: boolean, eslintrcFile?: string | null): Promise<NecessaryDependencies> → function hasNecessaryDependencies(baseDir: string, requiredPackages: MissingDependency[]): Promise<NecessaryDependencies>
changed: type NecessaryDependencies = { resolved: string } → type NecessaryDependencies = { resolved: Map<string, string>; missing: MissingDependency[] }
added: interface MissingDependency
added: property MissingDependency.file: string
added: property MissingDependency.pkg: string

added: function getOnline(): Promise<boolean>

added: function install(root: string, dependencies: string[] | null, { useYarn, isOnline, devDependencies }: InstallArgs): Promise<void>

added: function shouldUseYarn(): boolean

added: function installDependencies(baseDir: string, deps: any, dev?: boolean): Promise<void>
added: type Dependencies = { resolved: Map<string, string> }

added: const isYarn: (dir: string) => Promise<boolean>

added: function modifyRouteRegex(regex: string, restrictedPaths?: string[]): string

added: function missingDepsError(dir: string, missingPackages: MissingDependency[]): void

changed: function writeAppTypeDeclarations(baseDir: string): Promise<void> → function writeAppTypeDeclarations(baseDir: string, imageImportsEnabled: boolean): Promise<void>

changed: function verifyAndLint(dir: string, pagesDir: string, numWorkers: number | undefined, enableWorkerThreads: boolean | undefined): Promise<void> → function verifyAndLint(dir: string, cacheLocation: string, configLintDirs: string[] | undefined, numWorkers: number | undefined, enableWorkerThreads: boolean | undefined, telemetry: Telemetry): Promise<void>

changed: function verifyTypeScriptSetup(dir: string, pagesDir: string, typeCheckPreflight: boolean, cacheDir?: string): Promise<{ result?: TypeCheckResult; version: string | null }> → function verifyTypeScriptSetup(dir: string, pagesDir: string, typeCheckPreflight: boolean, imageImportsEnabled: boolean, cacheDir?: string): Promise<{ result?: TypeCheckResult; version: string | null }>

added: class Worker
added: constructor Worker(workerPath: string, options: FarmOptions & { timeout?: number; onRestart?: (method: string, args: any[], attempts: number) => void; exposedMethods: ReadonlyArray<string> })
added: method Worker.end(): ReturnType<JestWorker['end']>

removed: function isInAmpMode({ ampFirst, hybrid, hasQuery }?: { ampFirst?: boolean | undefined; hybrid?: boolean | undefined; hasQuery?: boolean | undefined }): boolean
removed: function useAmp(): boolean

removed: const AmpStateContext: React.Context<any>

removed: const AMP_RENDER_TARGET = '__NEXT_AMP_RENDER_TARGET__'
removed: const BLOCKED_PAGES: string[]
removed: const BUILD_ID_FILE = 'BUILD_ID'
removed: const BUILD_MANIFEST = 'build-manifest.json'
removed: const CLIENT_PUBLIC_FILES_PATH = 'public'
removed: const CLIENT_STATIC_FILES_PATH = 'static'
removed: const CLIENT_STATIC_FILES_RUNTIME = 'runtime'
removed: const CLIENT_STATIC_FILES_RUNTIME_AMP = 'amp'
removed: const CLIENT_STATIC_FILES_RUNTIME_MAIN = 'main'
removed: const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS = 'polyfills'
removed: const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = 'react-refresh'
removed: const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = 'webpack'
removed: const CONFIG_FILE = 'next.config.js'
removed: const DEV_CLIENT_PAGES_MANIFEST = '_devPagesManifest.json'
removed: const EXPORT_DETAIL = 'export-detail.json'
removed: const EXPORT_MARKER = 'export-marker.json'
removed: const FONT_MANIFEST = 'font-manifest.json'
removed: const IMAGES_MANIFEST = 'images-manifest.json'
removed: const OPTIMIZED_FONT_PROVIDERS: string[]
removed: const PAGES_MANIFEST = 'pages-manifest.json'
removed: const PERMANENT_REDIRECT_STATUS = 308
removed: const PHASE_DEVELOPMENT_SERVER = 'phase-development-server'
removed: const PHASE_EXPORT = 'phase-export'
removed: const PHASE_PRODUCTION_BUILD = 'phase-production-build'
removed: const PHASE_PRODUCTION_SERVER = 'phase-production-server'
removed: const PRERENDER_MANIFEST = 'prerender-manifest.json'
removed: const REACT_LOADABLE_MANIFEST = 'react-loadable-manifest.json'
removed: const ROUTES_MANIFEST = 'routes-manifest.json'
removed: const SERVERLESS_DIRECTORY = 'serverless'
removed: const SERVER_DIRECTORY = 'server'
removed: const SERVER_FILES_MANIFEST = 'required-server-files.json'
removed: const SERVER_PROPS_ID = '__N_SSP'
removed: const STATIC_PROPS_ID = '__N_SSG'
removed: const STATIC_STATUS_PAGES: string[]
removed: const STRING_LITERAL_DROP_BUNDLE = '__NEXT_DROP_CLIENT_FILE__'
removed: const TEMPORARY_REDIRECT_STATUS = 307

removed: const DocumentContext: React.Context<DocumentProps>

removed: default function dynamic(dynamicOptions: DynamicOptions | Loader, options?: DynamicOptions): React.ComponentType
removed: function noSSR(LoadableInitializer: LoadableFn, loadableOptions: LoadableOptions): React.ComponentType
removed: type DynamicOptions = LoadableBaseOptions & { render?(props: P, loaded: any): JSX.Element }
removed: type LoadableBaseOptions = LoadableGeneratedOptions & { loading?: ({ error, isLoading, pastDelay }: { error?: Error | null; isLoading?: boolean; pastDelay?: boolean; retry?: () => void;…
removed: type LoadableComponent = React.ComponentType
removed: type LoadableFn = (opts: LoadableOptions) => React.ComponentType
removed: type LoadableGeneratedOptions = { webpack?(): any; modules?(): LoaderMap }
removed: type LoadableOptions = LoadableBaseOptions & { render?(loader: any, props: any): JSX.Element }
removed: type Loader = (() => LoaderComponent) | LoaderComponent
removed: type LoaderComponent = Promise<React.ComponentType | { default: React.ComponentType }>
removed: type LoaderMap = { [mdule: string]: () => Loader<any> }

removed: default Head
removed: function Head({ children }: { children: React.ReactNode }): JSX.Element
removed: function defaultHead(inAmpMode?: boolean): JSX.Element[]
removed: namespace Head
removed: var Head.rewind: () => void

removed: const HeadManagerContext: React.Context<{ updateHead?: (state: any) => void; mountedInstances?: any; updateScripts?: (state: any) => void; scripts?: any }>

removed: function detectDomainLocale(domainItems: Array<{ http?: boolean; domain: string; locales?: string[]; defaultLocale: string }> | undefined, hostname?: string, detectedLocale?: string): { http?: boolean | undefined; domain: string; locales?: string[] | undefined; defaultLocale: string } | undefined

removed: function detectLocaleCookie(req: IncomingMessage, locales: string[]): string | undefined

removed: function normalizeLocalePath(pathname: string, locales?: string[]): { detectedLocale?: string; pathname: string }

removed: call LoadableExport.ILoadable(opts: any): React.ComponentClass
removed: const LoadableExport: LoadableExport.ILoadable
removed: export = LoadableExport
removed: interface LoadableExport.ILoadable
removed: method LoadableExport.ILoadable.Map(opts: any): React.ComponentType
removed: method LoadableExport.ILoadable.preloadAll(): Promise<any>
removed: namespace LoadableExport

removed: const LoadableContext: React.Context<CaptureFn | null>

removed: default function mitt(): MittEmitter
removed: type MittEmitter = { on(type: string, handler: Handler): void; off(type: string, handler: Handler): void; emit(type: string, ...evts: any[]): void }

removed: default processHTML
removed: function processHTML(html: string, data: renderOptions, options: postProcessOptions): Promise<string>

removed: const RouterContext: React.Context<NextRouter>

removed: constructor Router(pathname: string, query: ParsedUrlQuery, as: string, { initialProps, pageLoader, App, wrapApp, Component, err, subscription, isFallback, locale, locales, defaultLocale, domainLocales, isPreview }: { subscription: Subscription; initialProps: any; pageLoader: any; Component: ComponentType; App: AppComponent; wrapApp: (WrapAppComponent: AppComponent) => any; err?: Error; isFallbac…
removed: declare global
removed: default class Router implements BaseRouter
removed: function addBasePath(path: string): string
removed: function addLocale(path: string, locale?: string | false, defaultLocale?: string): string
removed: function delBasePath(path: string): string
removed: function delLocale(path: string, locale?: string): string
removed: function getDomainLocale(path: string, locale?: string | false, locales?: string[], domainLocales?: DomainLocales): string | false
removed: function hasBasePath(path: string): boolean
removed: function interpolateAs(route: string, asPathname: string, query: ParsedUrlQuery): { params: string[]; result: string }
removed: function isLocalURL(url: string): boolean
removed: function resolveHref(currentPath: string, href: Url, resolveAs?: boolean): string
removed: method Router._getData<T>(fn: () => Promise<T>): Promise<T>
removed: method Router._getServerData(dataHref: string): Promise<object>
removed: method Router._getStaticData(dataHref: string): Promise<object>
removed: method Router.abortComponentLoad(as: string, routeProps: RouteProperties): void
removed: method Router.back(): void
removed: method Router.beforePopState(cb: BeforePopStateCallback): void
removed: method Router.changeState(method: HistoryMethod, url: string, as: string, options?: TransitionOptions): void
removed: method Router.fetchComponent(route: string): Promise<GoodPageCache>
removed: method Router.getInitialProps(Component: ComponentType, ctx: NextPageContext): Promise<any>
removed: method Router.getRouteInfo(route: string, pathname: string, query: any, as: string, resolvedAs: string, routeProps: RouteProperties): Promise<PrivateRouteInfo>
removed: method Router.handleRouteInfoError(err: Error & { code: any; cancelled: boolean }, pathname: string, query: ParsedUrlQuery, as: string, routeProps: RouteProperties, loadErrorFail?: boolean): Promise<CompletePrivateRouteInfo>
removed: method Router.notify(data: PrivateRouteInfo, resetScroll: { x: number; y: number } | null): Promise<void>
removed: method Router.onlyAHashChange(as: string): boolean
removed: method Router.prefetch(url: string, asPath?: string, options?: PrefetchOptions): Promise<void>
removed: method Router.push(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>
removed: method Router.reload(): void
removed: method Router.replace(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>
removed: method Router.scrollToHash(as: string): void
removed: method Router.set(route: string, pathname: string, query: ParsedUrlQuery, as: string, data: PrivateRouteInfo, resetScroll: { x: number; y: number } | null): Promise<void>
removed: method Router.urlIsNew(asPath: string): boolean
removed: property Router._bps: BeforePopStateCallback | undefined
removed: property Router._inFlightRoute?: string
removed: property Router._shallow?: boolean
removed: property Router._wrapApp: (App: AppComponent) => any
removed: property Router.asPath: string
removed: property Router.basePath: string
removed: property Router.clc: ComponentLoadCancel
removed: property Router.components: { [pathname: string]: PrivateRouteInfo }
removed: property Router.defaultLocale?: string
removed: property Router.domainLocales?: DomainLocales
removed: property Router.events: MittEmitter
removed: property Router.isFallback: boolean
removed: property Router.isLocaleDomain: boolean
removed: property Router.isPreview: boolean
removed: property Router.isReady: boolean
removed: property Router.isSsr: boolean
removed: property Router.locale?: string
removed: property Router.locales?: string[]
removed: property Router.onPopState: (e: PopStateEvent) => void
removed: property Router.pageLoader: any
removed: property Router.pathname: string
removed: property Router.query: ParsedUrlQuery
removed: property Router.route: string
removed: property Router.sdc: { [asPath: string]: object }
removed: property Router.sdr: { [asPath: string]: Promise<object> }
removed: property Router.sub: Subscription
removed: static property Router.events: MittEmitter
removed: type AppComponent = ComponentType<AppProps>
removed: type AppProps = Pick<CompletePrivateRouteInfo, 'Component' | 'err'> & { router: Router } & Record<string, any>
removed: type BaseRouter = { route: string; pathname: string; query: ParsedUrlQuery; asPath: string; basePath: string; locale?: string; locales?: string[]; defaultLocale?: string; domain…
removed: type CompletePrivateRouteInfo = { Component: ComponentType; styleSheets: StyleSheetTuple[]; __N_SSG?: boolean; __N_SSP?: boolean; props?: Record<string, any>; err?: Error; error?: any }
removed: type NextRouter = BaseRouter & Pick<Router, 'push' | 'replace' | 'reload' | 'back' | 'prefetch' | 'beforePopState' | 'events' | 'isFallback' | 'isReady' | 'isPreview'>
removed: type PrefetchOptions = { priority?: boolean; locale?: string | false }
removed: type PrivateRouteInfo = (Omit<CompletePrivateRouteInfo, 'styleSheets'> & { initial: true }) | CompletePrivateRouteInfo

removed: default function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string

removed: function formatUrl(urlObj: UrlObject): string

removed: default function getAssetPathFromRoute(route: string, ext?: string): string

removed: default function getRouteFromAssetPath(assetPath: string, ext?: string): string

removed: export { getRouteMatcher } from './route-matcher'
removed: export { getRouteRegex } from './route-regex'
removed: export { getSortedRoutes } from './sorted-routes'
removed: export { isDynamicRoute } from './is-dynamic'

removed: function isDynamicRoute(route: string): boolean

removed: function parseRelativeUrl(url: string, base?: string): { pathname: string; query: import('querystring').ParsedUrlQuery; search: string; hash: string; href: string }

removed: const _default: (customRoute?: boolean) => (path: string) => (pathname: string | null | undefined, params?: any) => any
removed: const customRouteMatcherOptions: pathToRegexp.TokensToRegexpOptions & pathToRegexp.ParseOptions
removed: const matcherOptions: pathToRegexp.TokensToRegexpOptions & pathToRegexp.ParseOptions
removed: default _default
removed: export { pathToRegexp }

removed: const getSafeParamName: (paramName: string) => string
removed: default function prepareDestination(destination: string, params: Params, query: ParsedUrlQuery, appendParamsToQuery: boolean): { newUrl: string; parsedDestination: { query?: ParsedUrlQuery | undefined; protocol?: string | undefined; hostname?: string | undefined; port?: string | undefined } & { pathname: string; query: ParsedUrlQuery; search: string; hash: string; href: string } }
removed: function compileNonPath(value: string, params: Params): string
removed: function matchHas(req: IncomingMessage, has: RouteHas[], query: Params): false | Params

removed: function assign(target: URLSearchParams, ...searchParamsList: URLSearchParams[]): URLSearchParams
removed: function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery
removed: function urlQueryToSearchParams(urlQuery: ParsedUrlQuery): URLSearchParams

removed: default function resolveRewrites(asPath: string, pages: string[], rewrites: { beforeFiles: Rewrite[]; afterFiles: Rewrite[]; fallback: Rewrite[] }, query: ParsedUrlQuery, resolveHref: (path: string) => string, locales?: string[]): { matchedPage: boolean; parsedAs: ReturnType<typeof parseRelativeUrl>; asPath: string; resolvedHref?: string }

removed: default function resolveRewrites(): void

removed: function getRouteMatcher(routeRegex: ReturnType<typeof getRouteRegex>): (pathname: string | null | undefined) => false | { [paramName: string]: string | string[] }

removed: function getRouteRegex(normalizedRoute: string): { re: RegExp; namedRegex?: string; routeKeys?: { [named: string]: string }; groups: { [groupName: string]: Group } }
removed: interface Group
removed: property Group.optional: boolean
removed: property Group.pos: number
removed: property Group.repeat: boolean

removed: function getSortedRoutes(normalizedPages: string[]): string[]

removed: const _default: () => any
removed: default _default
removed: function setConfig(configValue: any): void

removed: constructor extends(props: any)
removed: default class extends Component<SideEffectProps>
removed: method extends.componentDidMount(): void
removed: method extends.componentDidUpdate(): void
removed: method extends.componentWillUnmount(): void
removed: method extends.render(): null
removed: property extends.emitChange: () => void

removed: function toBase64(str: string): string

removed: const SP: boolean
removed: const ST: boolean
removed: const urlObjectKeys: string[]
removed: function execOnce<T extends (...args: any[]) => ReturnType<T>>(fn: T): T
removed: function formatWithValidation(url: UrlObject): string
removed: function getDisplayName(Component: ComponentType): string
removed: function getLocationOrigin(): string
removed: function getURL(): string
removed: function isResSent(res: ServerResponse): boolean
removed: function loadGetInitialProps<C extends BaseContext, IP = {}, P = {}>(App: NextComponentType<C, IP, P>, ctx: C): Promise<IP>
removed: interface NextApiRequest extends IncomingMessage
removed: interface NextPageContext
removed: property NextApiRequest.body: any
removed: property NextApiRequest.cookies: { [key: string]: string }
removed: property NextApiRequest.env: Env
removed: property NextApiRequest.preview?: boolean
removed: property NextApiRequest.previewData?: PreviewData
removed: property NextApiRequest.query: { [key: string]: string | string[] }
removed: property NextPageContext.AppTree: AppTreeType
removed: property NextPageContext.asPath?: string
removed: property NextPageContext.defaultLocale?: string
removed: property NextPageContext.err?: (Error & { statusCode?: number }) | null
removed: property NextPageContext.locale?: string
removed: property NextPageContext.locales?: string[]
removed: property NextPageContext.pathname: string
removed: property NextPageContext.query: ParsedUrlQuery
removed: property NextPageContext.req?: IncomingMessage
removed: property NextPageContext.res?: ServerResponse
removed: type AppContextType<R extends NextRouter = NextRouter> = { Component: NextComponentType<NextPageContext>; AppTree: AppTreeType; ctx: NextPageContext; router: R }
removed: type AppInitialProps = { pageProps: any }
removed: type AppPropsType<R extends NextRouter = NextRouter, P = {}> = AppInitialProps & { Component: NextComponentType<NextPageContext, any, P>; router: R; __N_SSG?: boolean; __N_SSP?: boolean }
removed: type AppTreeType = ComponentType<AppInitialProps & { [name: string]: any }>
removed: type AppType = NextComponentType<AppContextType, AppInitialProps, AppPropsType>
removed: type BaseContext = { res?: ServerResponse; [k: string]: any }
removed: type ComponentsEnhancer = { enhanceApp?: Enhancer<AppType>; enhanceComponent?: Enhancer<NextComponentType> } | Enhancer<NextComponentType>
removed: type DocumentContext = NextPageContext & { renderPage: RenderPage }
removed: type DocumentInitialProps = RenderPageResult & { styles?: React.ReactElement[] | React.ReactFragment }
removed: type DocumentProps = DocumentInitialProps & { __NEXT_DATA__: NEXT_DATA; dangerousAsPath: string; docComponentsRendered: { Html?: boolean; Main?: boolean; Head?: boolean; NextScript…
removed: type DocumentType = NextComponentType<DocumentContext, DocumentInitialProps, DocumentProps> & { renderDocument(Document: DocumentType, props: DocumentProps): React.ReactElement }
removed: type Enhancer<C> = (Component: C) => C
removed: type NEXT_DATA = { props: Record<string, any>; page: string; query: ParsedUrlQuery; buildId: string; assetPrefix?: string; runtimeConfig?: { [key: string]: any }; nextExport?:…
removed: type NextApiHandler<T = any> = (req: NextApiRequest, res: NextApiResponse<T>) => void | Promise<void>
removed: type NextApiResponse<T = any> = ServerResponse & { send: Send<T>; json: Send<T>; status: (statusCode: number) => NextApiResponse<T>; redirect(url: string): NextApiResponse<T>; redirect(status…
removed: type NextComponentType<C extends BaseContext = NextPageContext, IP = {}, P = {}> = ComponentType & { getInitialProps?(context: C): IP | Promise<IP> }
removed: type NextWebVitalsMetric = { id: string; label: string; name: string; startTime: number; value: number }
removed: type RenderPage = (options?: ComponentsEnhancer) => RenderPageResult | Promise<RenderPageResult>
removed: type RenderPageResult = { html: string; head?: Array<JSX.Element | null> }

removed: class ApiError extends Error
removed: const SYMBOL_PREVIEW_DATA: unique symbol
removed: constructor ApiError(statusCode: number, message: string)
removed: function apiResolver(req: IncomingMessage, res: ServerResponse, query: any, resolverModule: any, apiContext: __ApiPreviewProps, propagateError: boolean): Promise<void>
removed: function getCookieParser(req: IncomingMessage): () => NextApiRequestCookies
removed: function parseBody(req: NextApiRequest, limit: string | number): Promise<any>
removed: function redirect(res: NextApiResponse, statusOrUrl: string | number, url?: string): NextApiResponse<any>
removed: function sendData(req: NextApiRequest, res: NextApiResponse, body: any): void
removed: function sendError(res: NextApiResponse, statusCode: number, message: string): void
removed: function sendJson(res: NextApiResponse, jsonBody: any): void
removed: function sendStatusCode(res: NextApiResponse, statusCode: number): NextApiResponse<any>
removed: function setLazyProp<T>({ req }: LazyProps, prop: string, getter: () => T): void
removed: function tryGetPreviewData(req: IncomingMessage, res: ServerResponse, options: __ApiPreviewProps): PreviewData
removed: readonly property ApiError.statusCode: number
removed: type NextApiRequestCookies = { [key: string]: string }
removed: type NextApiRequestQuery = { [key: string]: string | string[] }
removed: type __ApiPreviewProps = { previewModeId: string; previewModeEncryptionKey: string; previewModeSigningKey: string }

removed: default function loadConfig(phase: string, dir: string, customConfig?: object | null): Promise<import('./config-shared').NextConfig>
removed: export { DomainLocales } from './config-shared'
removed: export { NextConfig } from './config-shared'
removed: export { normalizeConfig } from './config-shared'
removed: function isTargetLikeServerless(target: string): boolean

removed: const defaultConfig: NextConfig
removed: function normalizeConfig(phase: string, config: any): any
removed: type DomainLocales = Array<{ http?: true; domain: string; locales?: string[]; defaultLocale: string }>
removed: type NextConfig = { [key: string]: any } & { i18n?: { locales: string[]; defaultLocale: string; domains?: DomainLocales; localeDetection?: false } | null; headers?: () => Promis…

removed: export { install }
removed: export { shouldLoadWithWebpack5 }
removed: function loadWebpackHook(phase: string, dir: string): Promise<void>

removed: function install(useWebpack5: boolean): void
removed: function shouldLoadWithWebpack5(phase: string, dir: string): Promise<CheckResult>
removed: type CheckReasons = 'test-mode' | 'no-config' | 'future-flag' | 'no-future-flag' | 'no-webpack-config' | 'webpack-config'
removed: type CheckResult = { enabled: boolean; reason: CheckReasons }

removed: function decryptWithSecret(secret: Buffer, encryptedData: string): string
removed: function encryptWithSecret(secret: Buffer, data: string): string

removed: function denormalizePagePath(page: string): string
removed: function normalizePathSep(path: string): string

removed: function getFontDefinitionFromManifest(url: string, manifest: FontManifest): string
removed: function getFontDefinitionFromNetwork(url: string): Promise<string>
removed: type FontManifest = Array<{ url: string; content: string }>

removed: function getPageFiles(buildManifest: BuildManifest, page: string): readonly string[]
removed: type BuildManifest = { devFiles: readonly string[]; ampDevFiles: readonly string[]; polyfillFiles: readonly string[]; lowPriorityFiles: readonly string[]; pages: { '/_app': readonl…

removed: default function getRouteFromEntrypoint(entryFile: string): string | null

removed: const VALID_LOADERS: readonly ['default', 'imgix', 'cloudinary', 'akamai']
removed: const imageConfigDefault: ImageConfig
removed: type ImageConfig = { deviceSizes: number[]; imageSizes: number[]; loader: LoaderValue; path: string; domains?: string[]; enableBlurryPlaceholder: boolean }
removed: type LoaderValue = typeof VALID_LOADERS[number]

removed: function getMaxAge(str: string | null): number
removed: function imageOptimizer(server: Server, req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery, nextConfig: NextConfig, distDir: string): Promise<{ finished: boolean }>

removed: class IncrementalCache
removed: constructor IncrementalCache({ max, dev, distDir, pagesDir, flushToDisk, locales }: { dev: boolean; max?: number; distDir: string; pagesDir: string; flushToDisk?: boolean; locales?: string[] })
removed: method IncrementalCache.get(pathname: string): Promise<IncrementalCacheValue | void>
removed: method IncrementalCache.getFallback(page: string): Promise<string>
removed: method IncrementalCache.set(pathname: string, data: { html?: string; pageData?: any; isNotFound?: boolean; isRedirect?: boolean }, revalidateSeconds?: number | false): Promise<void>
removed: property IncrementalCache.cache: LRUCache<string, IncrementalCacheValue>
removed: property IncrementalCache.incrementalOptions: { flushToDisk?: boolean; pagesDir?: string; distDir?: string; dev?: boolean }
removed: property IncrementalCache.locales?: string[]
removed: property IncrementalCache.prerenderManifest: PrerenderManifest

removed: function recursiveReadDirSync(dir: string, arr?: string[], rootDir?: string): string[]

removed: const codecs: { readonly mozjpeg: { readonly name: 'MozJPEG'; readonly extension: 'jpg'; readonly detectors: readonly [RegExp]; readonly dec: () => { decode?: ((buffer: Uint…
removed: const preprocessors: { readonly resize: { readonly name: 'Resize'; readonly description: 'Resize the image before compressing'; readonly instantiate: () => Promise<(buffer: Uint8Ar…

removed: function instantiateEmscriptenWasm(factory: (args: { locateFile: () => string }) => { decode?: (buffer: Buffer | Uint8Array, width: number, height: number, opts: any) => Buffer; encode?: (buffer: Buffer | Uint8Array, width: number, height: number, opts: any) => Buffer }, path: string): { decode?: ((buffer: Uint8Array | Buffer, width: number, height: number, opts: any) => Buffer) | undefined; enco…
removed: function pathify(path: string): string

removed: constructor ImageData(data: Buffer | Uint8Array | Uint8ClampedArray, width: number, height: number)
removed: default class ImageData
removed: get ImageData.data(): Buffer
removed: property ImageData.height: number
removed: property ImageData.width: number
removed: static method ImageData.from(input: ImageData): ImageData

removed: function decodeBuffer(_buffer: Buffer | Uint8Array): Promise<ImageData>
removed: function encodeJpeg(image: ImageData, { quality }: { quality: number }): Promise<Buffer | Uint8Array>
removed: function encodePng(image: ImageData): Promise<Buffer | Uint8Array>
removed: function encodeWebp(image: ImageData, { quality }: { quality: number }): Promise<Buffer | Uint8Array>
removed: function resize(image: ImageData, width: number): Promise<ImageData>
removed: function rotate(image: ImageData, numRotations: number): Promise<ImageData>

removed: function processBuffer(buffer: Buffer, operations: Operation[], encoding: Encoding, quality: number): Promise<Buffer>
removed: type Encoding = 'jpeg' | 'png' | 'webp'
removed: type Operation = RotateOperation | ResizeOperation

removed: const TextDecoder: any

removed: function interopDefault(mod: any): any
removed: function loadComponents(distDir: string, pathname: string, serverless: boolean): Promise<LoadComponentsReturnType>
removed: function loadDefaultErrorComponents(distDir: string): Promise<{ App: any; Document: any; Component: any; buildManifest: any; reactLoadableManifest: {}; ComponentMod: any }>
removed: type LoadComponentsReturnType = { Component: React.ComponentType; pageConfig?: PageConfig; buildManifest: BuildManifest; reactLoadableManifest: ReactLoadableManifest; Document: DocumentType;…
removed: type ManifestItem = { id: number | string; files: string[] }

removed: constructor Server({ dir, quiet, conf, dev, minimalMode, customServer }: ServerConstructor & { conf: NextConfig; minimalMode?: boolean })
removed: default class Server
removed: method Server.getRequestHandler(): (req: IncomingMessage, res: ServerResponse, parsedUrl?: UrlWithParsedQuery | undefined) => Promise<void>
removed: method Server.logError(err: Error): void
removed: method Server.prepare(): Promise<void>
removed: method Server.render(req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery, parsedUrl?: UrlWithParsedQuery): Promise<void>
removed: method Server.render404(req: IncomingMessage, res: ServerResponse, parsedUrl?: UrlWithParsedQuery, setHeaders?: boolean): Promise<void>
removed: method Server.renderError(err: Error | null, req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery, setHeaders?: boolean): Promise<void>
removed: method Server.renderErrorToHTML(err: Error | null, req: IncomingMessage, res: ServerResponse, _pathname: string, query?: ParsedUrlQuery): Promise<string | null>
removed: method Server.renderToHTML(req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery): Promise<string | null>
removed: method Server.serveStatic(req: IncomingMessage, res: ServerResponse, path: string, parsedUrl?: UrlWithParsedQuery): Promise<void>
removed: method Server.setAssetPrefix(prefix?: string): void
removed: protected get Server._isLikeServerless(): boolean
removed: protected method Server._beforeCatchAllRender(_req: IncomingMessage, _res: ServerResponse, _params: Params, _parsedUrl: UrlWithParsedQuery): Promise<boolean>
removed: protected method Server.close(): Promise<void>
removed: protected method Server.ensureApiPage(_pathname: string): Promise<void>
removed: protected method Server.generatePublicRoutes(): Route[]
removed: protected method Server.generateRoutes(): { basePath: string; headers: Route[]; rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }; fsRoutes: Route[]; redirects: Route[]; catchAllRoute: Route; pageChecker: PageChecker; useFileSystemPublicRoutes: boolean; dynamicRoutes: DynamicRoutes | undefined; locales: string[] }
removed: protected method Server.getCustomRoutes(): CustomRoutes
removed: protected method Server.getDynamicRoutes(): Array<DynamicRouteItem>
removed: protected method Server.getPrerenderManifest(): PrerenderManifest
removed: protected method Server.getPreviewProps(): __ApiPreviewProps
removed: protected method Server.getStaticPaths(pathname: string): Promise<{ staticPaths: string[] | undefined; fallbackMode: 'static' | 'blocking' | false }>
removed: protected method Server.hasPage(pathname: string): Promise<boolean>
removed: protected method Server.isServeableUrl(untrustedFileUrl: string): boolean
removed: protected method Server.readBuildId(): string
removed: protected method Server.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<void>
removed: protected method Server.sendHTML(req: IncomingMessage, res: ServerResponse, html: string): Promise<void>
removed: protected method Server.setImmutableAssetCacheControl(res: ServerResponse): void
removed: protected property Server.buildId: string
removed: protected property Server.customRoutes: CustomRoutes
removed: protected property Server.dir: string
removed: protected property Server.distDir: string
removed: protected property Server.dynamicRoutes?: DynamicRoutes
removed: protected property Server.hasStaticDir: boolean
removed: protected property Server.minimalMode: boolean
removed: protected property Server.nextConfig: NextConfig
removed: protected property Server.pagesDir?: string
removed: protected property Server.pagesManifest?: PagesManifest
removed: protected property Server.publicDir: string
removed: protected property Server.quiet: boolean
removed: protected property Server.renderOpts: { poweredByHeader: boolean; buildId: string; generateEtags: boolean; runtimeConfig?: { [key: string]: any }; assetPrefix?: string; canonicalBase: string; dev?: boolean; previewProps: __ApiPreviewProps; customServer?: boolean; ampOptimizerConfig?: { [key: string]: any }; basePath: string; optimizeFonts: boolean; images: string; fontManifest: FontManifest; opti…
removed: protected property Server.router: Router
removed: protected property Server.serverBuildDir: string
removed: type ServerConstructor = { dir?: string; quiet?: boolean; conf?: NextConfig | null; dev?: boolean; customServer?: boolean }

removed: export { denormalizePagePath } from './denormalize-page-path'
removed: export { normalizePathSep } from './denormalize-page-path'
removed: function normalizePagePath(page: string): string

removed: default function optimize(html: string, config: any): Promise<string>

removed: function renderToHTML(req: IncomingMessage, res: ServerResponse, pathname: string, query: ParsedUrlQuery, renderOpts: RenderOpts): Promise<string | null>
removed: type RenderOpts = LoadComponentsReturnType & RenderOptsPartial
removed: type RenderOptsPartial = { buildId: string; canonicalBase: string; runtimeConfig?: { [key: string]: any }; assetPrefix?: string; err?: Error | null; nextExport?: boolean; dev?: boolean…

removed: function getPagePath(page: string, distDir: string, serverless: boolean, dev?: boolean, locales?: string[]): string
removed: function pageNotFoundError(page: string): Error
removed: function requireFontManifest(distDir: string, serverless: boolean): any
removed: function requirePage(page: string, distDir: string, serverless: boolean): any

removed: const route: (path: string) => (pathname: string | null | undefined, params?: any) => any
removed: constructor Router({ basePath, headers, fsRoutes, rewrites, redirects, catchAllRoute, dynamicRoutes, pageChecker, useFileSystemPublicRoutes, locales }: { basePath: string; headers: Route[]; fsRoutes: Route[]; rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }; redirects: Route[]; catchAllRoute: Route; dynamicRoutes: DynamicRoutes | undefined; pageChecker: PageChecker; useF…
removed: default class Router
removed: method Router.addFsRoute(fsRoute: Route): void
removed: method Router.execute(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<boolean>
removed: method Router.setDynamicRoutes(routes?: DynamicRoutes): void
removed: property Router.basePath: string
removed: property Router.catchAllRoute: Route
removed: property Router.dynamicRoutes: DynamicRoutes
removed: property Router.fsRoutes: Route[]
removed: property Router.headers: Route[]
removed: property Router.locales: string[]
removed: property Router.pageChecker: PageChecker
removed: property Router.redirects: Route[]
removed: property Router.rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }
removed: property Router.useFileSystemPublicRoutes: boolean
removed: type DynamicRoutes = Array<{ page: string; match: RouteMatch }>
removed: type PageChecker = (pathname: string) => Promise<boolean>
removed: type Params = { [param: string]: any }
removed: type Route = { match: RouteMatch; has?: RouteHas[]; type: string; check?: boolean; statusCode?: number; name: string; requireBasePath?: false; internal?: true; fn: (req: In…
removed: type RouteMatch = (pathname: string | null | undefined) => false | Params

removed: function sendEtagResponse(req: IncomingMessage, res: ServerResponse, etag: string | undefined): boolean
removed: function sendPayload(req: IncomingMessage, res: ServerResponse, payload: any, type: 'html' | 'json', { generateEtags, poweredByHeader }: { generateEtags: boolean; poweredByHeader: boolean }, options?: PayloadOptions): void
removed: function setRevalidateHeaders(res: ServerResponse, options: PayloadOptions): void

removed: function getContentType(extWithoutDot: string): string | null
removed: function getExtension(contentType: string): string | null
removed: function serveStatic(req: IncomingMessage, res: ServerResponse, path: string): Promise<void>

removed: function cleanAmpPath(pathname: string): string
removed: function isBlockedPage(pathname: string): boolean

removed: function Container(p: any): any
removed: function createUrl(router: Router): { readonly query: import('querystring').ParsedUrlQuery; readonly pathname: string; readonly asPath: string; back: () => void; push: (url: string, as?: string | undefined) => Promise<boolean>; pushTo: (href: string, as?: string | undefined) => Promise<boolean>; replace: (url: string, as?: string | undefined) => Promise<boolean>; replaceTo: (href: string, as?: st…
removed: method App.componentDidCatch(error: Error, _errorInfo: ErrorInfo): void

removed: static method Document.renderDocument<Y>(DocumentComponent: new () => Document<Y>, props: DocumentProps & Y): React.ReactElement
removed: static property Head.propTypes: { nonce: PropTypes.Requireable<string>; crossOrigin: PropTypes.Requireable<string> }
removed: static property NextScript.propTypes: { nonce: PropTypes.Requireable<string>; crossOrigin: PropTypes.Requireable<string> }
changed: property Head.context: React.ContextType<typeof DocumentComponentContext> → property Head.context: React.ContextType<typeof HtmlContext>
changed: property NextScript.context: React.ContextType<typeof DocumentComponentContext> → property NextScript.context: React.ContextType<typeof HtmlContext>
changed: static method NextScript.getInlineScriptSource(documentProps: Readonly<DocumentProps>): string → static method NextScript.getInlineScriptSource(context: Readonly<HtmlProps>): string
changed: static property Head.contextType: React.Context<DocumentProps> → static property Head.contextType: React.Context<HtmlProps>
changed: static property NextScript.contextType: React.Context<DocumentProps> → static property NextScript.contextType: React.Context<HtmlProps>

added: class ApiError extends Error
added: const SYMBOL_PREVIEW_DATA: unique symbol
added: constructor ApiError(statusCode: number, message: string)
added: function apiResolver(req: IncomingMessage, res: ServerResponse, query: any, resolverModule: any, apiContext: __ApiPreviewProps, propagateError: boolean, dev?: boolean, page?: string): Promise<void>
added: function getCookieParser(headers: { [key: string]: undefined | string | string[] }): () => NextApiRequestCookies
added: function parseBody(req: NextApiRequest, limit: string | number): Promise<any>
added: function redirect(res: NextApiResponse, statusOrUrl: string | number, url?: string): NextApiResponse<any>
added: function sendData(req: NextApiRequest, res: NextApiResponse, body: any): void
added: function sendError(res: NextApiResponse, statusCode: number, message: string): void
added: function sendJson(res: NextApiResponse, jsonBody: any): void
added: function sendStatusCode(res: NextApiResponse, statusCode: number): NextApiResponse<any>
added: function setLazyProp<T>({ req }: LazyProps, prop: string, getter: () => T): void
added: function tryGetPreviewData(req: IncomingMessage, res: ServerResponse, options: __ApiPreviewProps): PreviewData
added: readonly property ApiError.statusCode: number
added: type NextApiRequestCookies = { [key: string]: string }
added: type NextApiRequestQuery = { [key: string]: string | string[] }
added: type __ApiPreviewProps = { previewModeId: string; previewModeEncryptionKey: string; previewModeSigningKey: string }

added: default function loadConfig(phase: string, dir: string, customConfig?: object | null): Promise<NextConfigComplete>
added: export { DomainLocale } from './config-shared'
added: export { NextConfig } from './config-shared'
added: export { normalizeConfig } from './config-shared'
added: function isTargetLikeServerless(target: string): boolean
added: function setHttpAgentOptions(options: NextConfigComplete['httpAgentOptions']): void

added: const defaultConfig: NextConfig
added: function normalizeConfig(phase: string, config: any): any
added: interface DomainLocale
added: interface ESLintConfig
added: interface I18NConfig
added: interface TypeScriptConfig
added: property DomainLocale.defaultLocale: string
added: property DomainLocale.domain: string
added: property DomainLocale.http?: true
added: property DomainLocale.locales?: string[]
added: property ESLintConfig.dirs?: string[]
added: property ESLintConfig.ignoreDuringBuilds?: boolean
added: property I18NConfig.defaultLocale: string
added: property I18NConfig.domains?: DomainLocale[]
added: property I18NConfig.localeDetection?: false
added: property I18NConfig.locales: string[]
added: property TypeScriptConfig.ignoreBuildErrors?: boolean
added: type NextConfig = { [key: string]: any } & { i18n?: I18NConfig | null; eslint?: ESLintConfig; typescript?: TypeScriptConfig; headers?: () => Promise<Header[]>; rewrites?: () =>…
added: type NextConfigComplete = NoOptionals<NextConfig>

added: export { install }
added: export { shouldLoadWithWebpack5 }
added: function loadWebpackHook(phase: string, dir: string): Promise<void>

added: function install(useWebpack5: boolean): void
added: function shouldLoadWithWebpack5(phase: string, dir: string): Promise<CheckResult>
added: type CheckReasons = 'test-mode' | 'default' | 'flag-disabled' | 'future-flag'
added: type CheckResult = { enabled: boolean; reason: CheckReasons }

added: function decryptWithSecret(secret: Buffer, encryptedData: string): string
added: function encryptWithSecret(secret: Buffer, data: string): string

added: function denormalizePagePath(page: string): string
added: function normalizePathSep(path: string): string

added: class WebpackHotMiddleware
added: constructor WebpackHotMiddleware(compilers: webpack.Compiler[])
added: property WebpackHotMiddleware.clientLatestStats: webpack.Stats | null
added: property WebpackHotMiddleware.close: () => void
added: property WebpackHotMiddleware.closed: boolean
added: property WebpackHotMiddleware.eventStream: EventStream
added: property WebpackHotMiddleware.latestStats: webpack.Stats | null
added: property WebpackHotMiddleware.middleware: (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
added: property WebpackHotMiddleware.onClientDone: (statsResult: webpack.Stats) => void
added: property WebpackHotMiddleware.onClientInvalid: () => void
added: property WebpackHotMiddleware.onServerDone: (statsResult: webpack.Stats) => void
added: property WebpackHotMiddleware.onServerInvalid: () => void
added: property WebpackHotMiddleware.publish: (payload: any) => void
added: property WebpackHotMiddleware.publishStats: (action: string, statsResult: webpack.Stats) => void
added: property WebpackHotMiddleware.serverError: boolean

added: constructor HotReloader(dir: string, { config, pagesDir, buildId, previewProps, rewrites }: { config: NextConfigComplete; pagesDir: string; buildId: string; previewProps: __ApiPreviewProps; rewrites: CustomRoutes['rewrites'] })
added: default class HotReloader
added: function renderScriptError(res: ServerResponse, error: Error, { verbose }?: { verbose?: boolean | undefined }): Promise<void>
added: method HotReloader.buildFallbackError(): Promise<void>
added: method HotReloader.ensurePage(page: string): Promise<any>
added: method HotReloader.getCompilationErrors(page: string): Promise<any[]>
added: method HotReloader.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlObject): Promise<{ finished?: true }>
added: method HotReloader.send(action?: string | any, ...args: any[]): void
added: method HotReloader.start(): Promise<void>
added: method HotReloader.stop(): Promise<void>
added: property HotReloader.isWebpack5: any
added: property HotReloader.serverStats: webpack.Stats | null

added: constructor DevServer(options: ServerConstructor & { conf: NextConfig; isNextDevCommand?: boolean })
added: default class DevServer extends Server
added: method DevServer._filterAmpDevelopmentScript(html: string, event: { line: number; col: number; code: string }): boolean
added: method DevServer.addExportPathMapRoutes(): Promise<void>
added: method DevServer.generateRoutes(): { basePath: string; headers: import('../router').Route[]; rewrites: { beforeFiles: import('../router').Route[]; afterFiles: import('../router').Route[]; fallback: import('../router').Route[] }; redirects: import('../router').Route[]; catchAllRoute: import('../router').Route; pageChecker: import('../router').PageChecker; useFileSystemPublicRoutes: boolean; dynami…
added: method DevServer.getCompilationError(page: string): Promise<any>
added: method DevServer.hasPublicFile(path: string): Promise<boolean>
added: method DevServer.prepare(): Promise<void>
added: method DevServer.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<void>
added: method DevServer.startWatcher(): Promise<void>
added: method DevServer.stopWatcher(): Promise<void>
added: protected method DevServer._beforeCatchAllRender(req: IncomingMessage, res: ServerResponse, params: Params, parsedUrl: UrlWithParsedQuery): Promise<boolean>
added: protected method DevServer.close(): Promise<void>
added: protected method DevServer.ensureApiPage(pathname: string): Promise<any>
added: protected method DevServer.findPageComponents(pathname: string, query?: ParsedUrlQuery, params?: Params | null): Promise<FindComponentsResult | null>
added: protected method DevServer.generatePublicRoutes(): never[]
added: protected method DevServer.getCustomRoutes(): CustomRoutes
added: protected method DevServer.getDynamicRoutes(): never[]
added: protected method DevServer.getFallbackErrorComponents(): Promise<LoadComponentsReturnType | null>
added: protected method DevServer.getPreviewProps(): __ApiPreviewProps
added: protected method DevServer.getStaticPaths(pathname: string): Promise<{ staticPaths: string[] | undefined; fallbackMode: false | 'static' | 'blocking' }>
added: protected method DevServer.hasPage(pathname: string): Promise<boolean>
added: protected method DevServer.isServeableUrl(untrustedFileUrl: string): boolean
added: protected method DevServer.readBuildId(): string
added: protected method DevServer.setImmutableAssetCacheControl(res: ServerResponse): void
added: protected property DevServer.sortedRoutes?: string[]
added: protected property DevServer.staticPathsWorker: import('jest-worker').Worker & { loadStaticPaths: typeof import('./static-paths-worker').loadStaticPaths }

added: const ADDED: unique symbol
added: const BUILDING: unique symbol
added: const BUILT: unique symbol
added: default function onDemandEntryHandler(watcher: any, multiCompiler: webpack.MultiCompiler, { pagesDir, pageExtensions, maxInactiveAge, pagesBufferLength }: { pagesDir: string; pageExtensions: string[]; maxInactiveAge: number; pagesBufferLength: number }): { ensurePage(page: string): Promise<void>; middleware(req: IncomingMessage, res: ServerResponse, next: Function): any }
added: let entries: { [page: string]: { serverBundlePath: string; clientBundlePath: string; absolutePagePath: string; status?: typeof ADDED | typeof BUILDING | typeof BUILT; lastA…

added: function loadStaticPaths(distDir: string, pathname: string, serverless: boolean, config: RuntimeConfig, httpAgentOptions: NextConfigComplete['httpAgentOptions'], locales?: string[], defaultLocale?: string): Promise<Omit<import('../../types').GetStaticPathsResult<import('querystring').ParsedUrlQuery>, 'paths'> & { paths: string[]; encodedPaths: string[] }>

added: function getFontDefinitionFromManifest(url: string, manifest: FontManifest): string
added: function getFontDefinitionFromNetwork(url: string): Promise<string>
added: type FontManifest = Array<{ url: string; content: string }>

added: function getPageFiles(buildManifest: BuildManifest, page: string): readonly string[]
added: type BuildManifest = { devFiles: readonly string[]; ampDevFiles: readonly string[]; polyfillFiles: readonly string[]; lowPriorityFiles: readonly string[]; pages: { '/_app': readonl…

added: default function getRouteFromEntrypoint(entryFile: string): string | null

removed: class WebpackHotMiddleware
removed: constructor WebpackHotMiddleware(compilers: webpack.Compiler[])
removed: property WebpackHotMiddleware.clientLatestStats: webpack.Stats | null
removed: property WebpackHotMiddleware.close: () => void
removed: property WebpackHotMiddleware.closed: boolean
removed: property WebpackHotMiddleware.eventStream: EventStream
removed: property WebpackHotMiddleware.latestStats: webpack.Stats | null
removed: property WebpackHotMiddleware.middleware: (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void
removed: property WebpackHotMiddleware.onClientDone: (statsResult: webpack.Stats) => void
removed: property WebpackHotMiddleware.onClientInvalid: () => void
removed: property WebpackHotMiddleware.onServerDone: (statsResult: webpack.Stats) => void
removed: property WebpackHotMiddleware.onServerInvalid: () => void
removed: property WebpackHotMiddleware.publish: (payload: any) => void
removed: property WebpackHotMiddleware.publishStats: (action: string, statsResult: webpack.Stats) => void
removed: property WebpackHotMiddleware.serverError: boolean

removed: constructor HotReloader(dir: string, { config, pagesDir, buildId, previewProps, rewrites }: { config: NextConfig; pagesDir: string; buildId: string; previewProps: __ApiPreviewProps; rewrites: CustomRoutes['rewrites'] })
removed: default class HotReloader
removed: function renderScriptError(res: ServerResponse, error: Error, { verbose }?: { verbose?: boolean | undefined }): Promise<void>
removed: method HotReloader.buildFallbackError(): Promise<void>
removed: method HotReloader.ensurePage(page: string): Promise<any>
removed: method HotReloader.getCompilationErrors(page: string): Promise<any[]>
removed: method HotReloader.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlObject): Promise<{ finished?: true }>
removed: method HotReloader.send(action?: string | any, ...args: any[]): void
removed: method HotReloader.start(): Promise<void>
removed: method HotReloader.stop(): Promise<void>
removed: property HotReloader.isWebpack5: any

added: const VALID_LOADERS: readonly ['default', 'imgix', 'cloudinary', 'akamai', 'custom']
added: const imageConfigDefault: ImageConfig
added: type ImageConfig = { deviceSizes: number[]; imageSizes: number[]; loader: LoaderValue; path: string; domains?: string[]; disableStaticImages?: boolean; minimumCacheTTL?: number }
added: type LoaderValue = typeof VALID_LOADERS[number]

added: function detectContentType(buffer: Buffer): 'image/svg+xml' | 'image/webp' | 'image/png' | 'image/jpeg' | 'image/gif' | null
added: function getMaxAge(str: string | null): number
added: function imageOptimizer(server: Server, req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery, nextConfig: NextConfig, distDir: string, isDev?: boolean): Promise<{ finished: boolean }>
added: function resizeImage(content: Buffer, dimension: 'width' | 'height', size: number, extension: 'webp' | 'png' | 'jpeg', quality: number): Promise<Buffer>

added: class IncrementalCache
added: constructor IncrementalCache({ max, dev, distDir, pagesDir, flushToDisk, locales }: { dev: boolean; max?: number; distDir: string; pagesDir: string; flushToDisk?: boolean; locales?: string[] })
added: method IncrementalCache.get(pathname: string): Promise<IncrementalCacheEntry | null>
added: method IncrementalCache.getFallback(page: string): Promise<string>
added: method IncrementalCache.set(pathname: string, data: IncrementalCacheValue | null, revalidateSeconds?: number | false): Promise<void>
added: property IncrementalCache.cache?: LRUCache<string, IncrementalCacheEntry>
added: property IncrementalCache.incrementalOptions: { flushToDisk?: boolean; pagesDir?: string; distDir?: string; dev?: boolean }
added: property IncrementalCache.locales?: string[]
added: property IncrementalCache.prerenderManifest: PrerenderManifest
added: type IncrementalCacheValue = CachedRedirectValue | CachedPageValue

added: function recursiveReadDirSync(dir: string, arr?: string[], rootDir?: string): string[]

added: const codecs: { readonly mozjpeg: { readonly name: 'MozJPEG'; readonly extension: 'jpg'; readonly detectors: readonly [RegExp]; readonly dec: () => { decode?: ((buffer: Uint…
added: const preprocessors: { readonly resize: { readonly name: 'Resize'; readonly description: 'Resize the image before compressing'; readonly instantiate: () => Promise<(buffer: Buffer…

added: function instantiateEmscriptenWasm(factory: (args: { locateFile: () => string }) => { decode?: (buffer: Buffer | Uint8Array, width: number, height: number, opts: any) => Buffer; encode?: (buffer: Buffer | Uint8Array, width: number, height: number, opts: any) => Buffer }, path: string): { decode?: ((buffer: Buffer | Uint8Array, width: number, height: number, opts: any) => Buffer) | undefined; enco…
added: function pathify(path: string): string

added: constructor ImageData(data: Buffer | Uint8Array | Uint8ClampedArray, width: number, height: number)
added: default class ImageData
added: get ImageData.data(): Buffer
added: property ImageData.height: number
added: property ImageData.width: number
added: static method ImageData.from(input: ImageData): ImageData

added: function decodeBuffer(_buffer: Buffer | Uint8Array): Promise<ImageData>
added: function encodeJpeg(image: ImageData, { quality }: { quality: number }): Promise<Buffer | Uint8Array>
added: function encodePng(image: ImageData): Promise<Buffer | Uint8Array>
added: function encodeWebp(image: ImageData, { quality }: { quality: number }): Promise<Buffer | Uint8Array>
added: function resize({ image, width, height }: ResizeOpts): Promise<ImageData>
added: function rotate(image: ImageData, numRotations: number): Promise<ImageData>

added: function processBuffer(buffer: Buffer, operations: Operation[], encoding: Encoding, quality: number): Promise<Buffer>
added: type Encoding = 'jpeg' | 'png' | 'webp'
added: type Operation = RotateOperation | ResizeOperation

added: const TextDecoder: any

added: function interopDefault(mod: any): any
added: function loadComponents(distDir: string, pathname: string, serverless: boolean): Promise<LoadComponentsReturnType>
added: function loadDefaultErrorComponents(distDir: string): Promise<{ App: any; Document: any; Component: any; buildManifest: any; reactLoadableManifest: {}; ComponentMod: any }>
added: type LoadComponentsReturnType = { Component: React.ComponentType; pageConfig?: PageConfig; buildManifest: BuildManifest; reactLoadableManifest: ReactLoadableManifest; Document: DocumentType;…
added: type ManifestItem = { id: number | string; files: string[] }

removed: constructor DevServer(options: ServerConstructor & { conf: NextConfig; isNextDevCommand?: boolean })
removed: default class DevServer extends Server
removed: method DevServer._filterAmpDevelopmentScript(html: string, event: { line: number; col: number; code: string }): boolean
removed: method DevServer.addExportPathMapRoutes(): Promise<void>
removed: method DevServer.generateRoutes(): { basePath: string; headers: import('../next-server/server/router').Route[]; rewrites: { beforeFiles: import('../next-server/server/router').Route[]; afterFiles: import('../next-server/server/router').Route[]; fallback: import('../next-server/server/router').Route[] }; redirects: import('../next-server/server/router').Route[]; catchAllRoute: import('../next-serv…
removed: method DevServer.getCompilationError(page: string): Promise<any>
removed: method DevServer.hasPublicFile(path: string): Promise<boolean>
removed: method DevServer.prepare(): Promise<void>
removed: method DevServer.renderErrorToHTML(err: Error | null, req: IncomingMessage, res: ServerResponse, pathname: string, query: { [key: string]: string }): Promise<string | null>
removed: method DevServer.renderToHTML(req: IncomingMessage, res: ServerResponse, pathname: string, query: { [key: string]: string }): Promise<string | null>
removed: method DevServer.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<void>
removed: method DevServer.sendHTML(req: IncomingMessage, res: ServerResponse, html: string): Promise<void>
removed: method DevServer.startWatcher(): Promise<void>
removed: method DevServer.stopWatcher(): Promise<void>
removed: protected method DevServer._beforeCatchAllRender(req: IncomingMessage, res: ServerResponse, params: Params, parsedUrl: UrlWithParsedQuery): Promise<boolean>
removed: protected method DevServer.close(): Promise<void>
removed: protected method DevServer.ensureApiPage(pathname: string): Promise<any>
removed: protected method DevServer.generatePublicRoutes(): never[]
removed: protected method DevServer.getCustomRoutes(): CustomRoutes
removed: protected method DevServer.getDynamicRoutes(): never[]
removed: protected method DevServer.getPreviewProps(): __ApiPreviewProps
removed: protected method DevServer.getStaticPaths(pathname: string): Promise<{ staticPaths: string[] | undefined; fallbackMode: false | 'static' | 'blocking' }>
removed: protected method DevServer.hasPage(pathname: string): Promise<boolean>
removed: protected method DevServer.isServeableUrl(untrustedFileUrl: string): boolean
removed: protected method DevServer.readBuildId(): string
removed: protected method DevServer.setImmutableAssetCacheControl(res: ServerResponse): void
removed: protected property DevServer.sortedRoutes?: string[]
removed: protected property DevServer.staticPathsWorker: import('jest-worker').Worker & { loadStaticPaths: typeof import('./static-paths-worker').loadStaticPaths }

added: class WrappedBuildError extends Error
added: constructor Server({ dir, quiet, conf, dev, minimalMode, customServer }: ServerConstructor & { conf: NextConfig; minimalMode?: boolean })
added: constructor WrappedBuildError(innerError: Error)
added: default class Server
added: method Server.getRequestHandler(): (req: IncomingMessage, res: ServerResponse, parsedUrl?: UrlWithParsedQuery | undefined) => Promise<void>
added: method Server.logError(err: Error): void
added: method Server.prepare(): Promise<void>
added: method Server.render(req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery, parsedUrl?: UrlWithParsedQuery): Promise<void>
added: method Server.render404(req: IncomingMessage, res: ServerResponse, parsedUrl?: UrlWithParsedQuery, setHeaders?: boolean): Promise<void>
added: method Server.renderError(err: Error | null, req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery, setHeaders?: boolean): Promise<void>
added: method Server.renderErrorToHTML(err: Error | null, req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery): Promise<string | null>
added: method Server.renderToHTML(req: IncomingMessage, res: ServerResponse, pathname: string, query?: ParsedUrlQuery): Promise<string | null>
added: method Server.serveStatic(req: IncomingMessage, res: ServerResponse, path: string, parsedUrl?: UrlWithParsedQuery): Promise<void>
added: method Server.setAssetPrefix(prefix?: string): void
added: property WrappedBuildError.innerError: Error
added: protected get Server._isLikeServerless(): boolean
added: protected method Server._beforeCatchAllRender(_req: IncomingMessage, _res: ServerResponse, _params: Params, _parsedUrl: UrlWithParsedQuery): Promise<boolean>
added: protected method Server.close(): Promise<void>
added: protected method Server.ensureApiPage(_pathname: string): Promise<void>
added: protected method Server.findPageComponents(pathname: string, query?: ParsedUrlQuery, params?: Params | null): Promise<FindComponentsResult | null>
added: protected method Server.generatePublicRoutes(): Route[]
added: protected method Server.generateRoutes(): { basePath: string; headers: Route[]; rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }; fsRoutes: Route[]; redirects: Route[]; catchAllRoute: Route; pageChecker: PageChecker; useFileSystemPublicRoutes: boolean; dynamicRoutes: DynamicRoutes | undefined; locales: string[] }
added: protected method Server.getCustomRoutes(): CustomRoutes
added: protected method Server.getDynamicRoutes(): Array<DynamicRouteItem>
added: protected method Server.getFallbackErrorComponents(): Promise<LoadComponentsReturnType | null>
added: protected method Server.getPrerenderManifest(): PrerenderManifest
added: protected method Server.getPreviewProps(): __ApiPreviewProps
added: protected method Server.getStaticPaths(pathname: string): Promise<{ staticPaths: string[] | undefined; fallbackMode: 'static' | 'blocking' | false }>
added: protected method Server.hasPage(pathname: string): Promise<boolean>
added: protected method Server.isServeableUrl(untrustedFileUrl: string): boolean
added: protected method Server.readBuildId(): string
added: protected method Server.run(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<void>
added: protected method Server.setImmutableAssetCacheControl(res: ServerResponse): void
added: protected property Server.buildId: string
added: protected property Server.customRoutes: CustomRoutes
added: protected property Server.dir: string
added: protected property Server.distDir: string
added: protected property Server.dynamicRoutes?: DynamicRoutes
added: protected property Server.hasStaticDir: boolean
added: protected property Server.minimalMode: boolean
added: protected property Server.nextConfig: NextConfigComplete
added: protected property Server.pagesDir?: string
added: protected property Server.pagesManifest?: PagesManifest
added: protected property Server.publicDir: string
added: protected property Server.quiet: boolean
added: protected property Server.renderOpts: { poweredByHeader: boolean; buildId: string; generateEtags: boolean; runtimeConfig?: { [key: string]: any }; assetPrefix?: string; canonicalBase: string; dev?: boolean; previewProps: __ApiPreviewProps; customServer?: boolean; ampOptimizerConfig?: { [key: string]: any }; basePath: string; optimizeFonts: boolean; images: string; fontManifest: FontManifest; opti…
added: protected property Server.router: Router
added: protected property Server.serverBuildDir: string
added: type FindComponentsResult = { components: LoadComponentsReturnType; query: ParsedUrlQuery }
added: type ServerConstructor = { dir?: string; quiet?: boolean; conf?: NextConfig | null; dev?: boolean; customServer?: boolean }

added: export { denormalizePagePath } from './denormalize-page-path'
added: export { normalizePathSep } from './denormalize-page-path'
added: function normalizePagePath(page: string): string

removed: const ADDED: unique symbol
removed: const BUILDING: unique symbol
removed: const BUILT: unique symbol
removed: default function onDemandEntryHandler(watcher: any, multiCompiler: webpack.MultiCompiler, { pagesDir, pageExtensions, maxInactiveAge, pagesBufferLength }: { pagesDir: string; pageExtensions: string[]; maxInactiveAge: number; pagesBufferLength: number }): { ensurePage(page: string): Promise<unknown>; middleware(req: IncomingMessage, res: ServerResponse, next: Function): any }
removed: let entries: { [page: string]: { serverBundlePath: string; clientBundlePath: string; absolutePagePath: string; status?: typeof ADDED | typeof BUILDING | typeof BUILT; lastA…

added: default function optimize(html: string, config: any): Promise<string>

added: function renderToHTML(req: IncomingMessage, res: ServerResponse, pathname: string, query: ParsedUrlQuery, renderOpts: RenderOpts): Promise<RenderResult | null>
added: type RenderOpts = LoadComponentsReturnType & RenderOptsPartial
added: type RenderOptsPartial = { buildId: string; canonicalBase: string; runtimeConfig?: { [key: string]: any }; assetPrefix?: string; err?: Error | null; nextExport?: boolean; dev?: boolean…

added: function getPagePath(page: string, distDir: string, serverless: boolean, dev?: boolean, locales?: string[]): string
added: function pageNotFoundError(page: string): Error
added: function requireFontManifest(distDir: string, serverless: boolean): any
added: function requirePage(page: string, distDir: string, serverless: boolean): any

added: constructor ResponseCache(incrementalCache: IncrementalCache)
added: default class ResponseCache
added: method ResponseCache.get(key: string | null, responseGenerator: ResponseGenerator): Promise<ResponseCacheEntry | null>
added: property ResponseCache.incrementalCache: IncrementalCache
added: property ResponseCache.pendingResponses: Map<string, Promise<ResponseCacheEntry | null>>
added: type ResponseCacheEntry = { revalidate?: number | false; value: ResponseCacheValue | null }
added: type ResponseCacheValue = CachedRedirectValue | CachedPageValue

added: const route: (path: string, regexModifier?: ((regex: string) => string) | undefined) => (pathname: string | null | undefined, params?: any) => any
added: constructor Router({ basePath, headers, fsRoutes, rewrites, redirects, catchAllRoute, dynamicRoutes, pageChecker, useFileSystemPublicRoutes, locales }: { basePath: string; headers: Route[]; fsRoutes: Route[]; rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }; redirects: Route[]; catchAllRoute: Route; dynamicRoutes: DynamicRoutes | undefined; pageChecker: PageChecker; useF…
added: default class Router
added: method Router.addFsRoute(fsRoute: Route): void
added: method Router.execute(req: IncomingMessage, res: ServerResponse, parsedUrl: UrlWithParsedQuery): Promise<boolean>
added: method Router.setDynamicRoutes(routes?: DynamicRoutes): void
added: property Router.basePath: string
added: property Router.catchAllRoute: Route
added: property Router.dynamicRoutes: DynamicRoutes
added: property Router.fsRoutes: Route[]
added: property Router.headers: Route[]
added: property Router.locales: string[]
added: property Router.pageChecker: PageChecker
added: property Router.redirects: Route[]
added: property Router.rewrites: { beforeFiles: Route[]; afterFiles: Route[]; fallback: Route[] }
added: property Router.useFileSystemPublicRoutes: boolean
added: type DynamicRoutes = Array<{ page: string; match: RouteMatch }>
added: type PageChecker = (pathname: string) => Promise<boolean>
added: type Params = { [param: string]: any }
added: type Route = { match: RouteMatch; has?: RouteHas[]; type: string; check?: boolean; statusCode?: number; name: string; requireBasePath?: false; internal?: true; fn: (req: In…
added: type RouteMatch = (pathname: string | null | undefined) => false | Params

added: function sendEtagResponse(req: IncomingMessage, res: ServerResponse, etag: string | undefined): boolean
added: function sendPayload(req: IncomingMessage, res: ServerResponse, payload: any, type: 'html' | 'json', { generateEtags, poweredByHeader }: { generateEtags: boolean; poweredByHeader: boolean }, options?: PayloadOptions): void
added: function sendRenderResult({ req, res, resultOrPayload, type, generateEtags, poweredByHeader, options }: { req: IncomingMessage; res: ServerResponse; resultOrPayload: RenderResult | string; type: 'html' | 'json'; generateEtags: boolean; poweredByHeader: boolean; options?: PayloadOptions }): Promise<void>
added: function setRevalidateHeaders(res: ServerResponse, options: PayloadOptions): void
added: type PayloadOptions = { private: true } | { private: boolean; stateful: true } | { private: boolean; stateful: false; revalidate: number | false }

added: function getContentType(extWithoutDot: string): string | null
added: function getExtension(contentType: string): string | null
added: function serveStatic(req: IncomingMessage, res: ServerResponse, path: string): Promise<void>

removed: function loadStaticPaths(distDir: string, pathname: string, serverless: boolean, config: RuntimeConfig, locales?: string[], defaultLocale?: string): Promise<Pick<import('../types').GetStaticPathsResult<import('querystring').ParsedUrlQuery>, 'fallback'> & { paths: string[]; encodedPaths: string[] }>

added: function cleanAmpPath(pathname: string): string
added: function isBlockedPage(pathname: string): boolean
added: function mergeResults(results: Array<RenderResult>): RenderResult
added: function resultsToString(results: Array<RenderResult>): Promise<string>
added: type RenderResult = Observable<string>

added: function isInAmpMode({ ampFirst, hybrid, hasQuery }?: { ampFirst?: boolean | undefined; hybrid?: boolean | undefined; hasQuery?: boolean | undefined }): boolean
added: function useAmp(): boolean

added: const AmpStateContext: React.Context<any>

added: const BLOCKED_PAGES: string[]
added: const BODY_RENDER_TARGET = '__NEXT_BODY_RENDER_TARGET__'
added: const BUILD_ID_FILE = 'BUILD_ID'
added: const BUILD_MANIFEST = 'build-manifest.json'
added: const CLIENT_PUBLIC_FILES_PATH = 'public'
added: const CLIENT_STATIC_FILES_PATH = 'static'
added: const CLIENT_STATIC_FILES_RUNTIME = 'runtime'
added: const CLIENT_STATIC_FILES_RUNTIME_AMP = 'amp'
added: const CLIENT_STATIC_FILES_RUNTIME_MAIN = 'main'
added: const CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL: unique symbol
added: const CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH = 'react-refresh'
added: const CLIENT_STATIC_FILES_RUNTIME_WEBPACK = 'webpack'
added: const CONFIG_FILE = 'next.config.js'
added: const DEV_CLIENT_PAGES_MANIFEST = '_devPagesManifest.json'
added: const EXPORT_DETAIL = 'export-detail.json'
added: const EXPORT_MARKER = 'export-marker.json'
added: const FONT_MANIFEST = 'font-manifest.json'
added: const GOOGLE_FONT_PROVIDER = 'https://fonts.googleapis.com/css'
added: const IMAGES_MANIFEST = 'images-manifest.json'
added: const OPTIMIZED_FONT_PROVIDERS: { url: string; preconnect: string }[]
added: const PAGES_MANIFEST = 'pages-manifest.json'
added: const PERMANENT_REDIRECT_STATUS = 308
added: const PHASE_DEVELOPMENT_SERVER = 'phase-development-server'
added: const PHASE_EXPORT = 'phase-export'
added: const PHASE_PRODUCTION_BUILD = 'phase-production-build'
added: const PHASE_PRODUCTION_SERVER = 'phase-production-server'
added: const PRERENDER_MANIFEST = 'prerender-manifest.json'
added: const REACT_LOADABLE_MANIFEST = 'react-loadable-manifest.json'
added: const ROUTES_MANIFEST = 'routes-manifest.json'
added: const SERVERLESS_DIRECTORY = 'serverless'
added: const SERVER_DIRECTORY = 'server'
added: const SERVER_FILES_MANIFEST = 'required-server-files.json'
added: const SERVER_PROPS_ID = '__N_SSP'
added: const STATIC_PROPS_ID = '__N_SSG'
added: const STATIC_STATUS_PAGES: string[]
added: const STRING_LITERAL_DROP_BUNDLE = '__NEXT_DROP_CLIENT_FILE__'
added: const TEMPORARY_REDIRECT_STATUS = 307
added: const TRACE_OUTPUT_VERSION = 1

added: default function dynamic(dynamicOptions: DynamicOptions | Loader, options?: DynamicOptions): React.ComponentType
added: function noSSR(LoadableInitializer: LoadableFn, loadableOptions: LoadableBaseOptions): React.ComponentType
added: type DynamicOptions = LoadableBaseOptions
added: type LoadableBaseOptions = LoadableGeneratedOptions & { loading?: ({ error, isLoading, pastDelay }: { error?: Error | null; isLoading?: boolean; pastDelay?: boolean; retry?: () => void;…
added: type LoadableComponent = React.ComponentType
added: type LoadableFn = (opts: LoadableOptions | LoadableSuspenseOptions) => React.ComponentType
added: type LoadableGeneratedOptions = { webpack?(): any; modules?(): LoaderMap }
added: type LoadableOptions = LoadableBaseOptions
added: type LoadableSuspenseOptions = { loader: Loader; suspense?: boolean }
added: type Loader = (() => LoaderComponent) | LoaderComponent
added: type LoaderComponent = Promise<React.ComponentType | { default: React.ComponentType }>
added: type LoaderMap = { [mdule: string]: () => Loader<any> }

added: default Head
added: function Head({ children }: { children: React.ReactNode }): JSX.Element
added: function defaultHead(inAmpMode?: boolean): JSX.Element[]

added: const HeadManagerContext: React.Context<{ updateHead?: (state: any) => void; mountedInstances?: any; updateScripts?: (state: any) => void; scripts?: any; getIsSsr?: () => boolean }>

added: function detectDomainLocale(domainItems?: DomainLocale[], hostname?: string, detectedLocale?: string): DomainLocale | undefined

added: function detectLocaleCookie(req: IncomingMessage, locales: string[]): string | undefined

added: function getLocaleMetadata(params: Params): { path: import('./normalize-locale-path').PathLocale; domain: DomainLocale | undefined; defaultLocale: string; locale: string; redirect: string | undefined; trailingSlash: boolean | undefined }

added: function normalizeLocalePath(pathname: string, locales?: string[]): PathLocale
added: interface PathLocale
added: property PathLocale.detectedLocale?: string
added: property PathLocale.pathname: string

added: call LoadableExport.ILoadable(opts: any): React.ComponentClass
added: const LoadableExport: LoadableExport.ILoadable
added: export = LoadableExport
added: interface LoadableExport.ILoadable
added: method LoadableExport.ILoadable.Map(opts: any): React.ComponentType
added: method LoadableExport.ILoadable.preloadAll(): Promise<any>
added: namespace LoadableExport

added: const LoadableContext: React.Context<CaptureFn | null>

added: default function mitt(): MittEmitter<string>
added: type MittEmitter<T> = { on(type: T, handler: Handler): void; off(type: T, handler: Handler): void; emit(type: T, ...evts: any[]): void }

added: default processHTML
added: function processHTML(html: string, data: renderOptions, options: postProcessOptions): Promise<string>

added: const RouterContext: React.Context<NextRouter>

added: constructor Router(pathname: string, query: ParsedUrlQuery, as: string, { initialProps, pageLoader, App, wrapApp, Component, err, subscription, isFallback, locale, locales, defaultLocale, domainLocales, isPreview }: { subscription: Subscription; initialProps: any; pageLoader: any; Component: ComponentType; App: AppComponent; wrapApp: (WrapAppComponent: AppComponent) => any; err?: Error; isFallbac…
added: declare global
added: default class Router implements BaseRouter
added: function addBasePath(path: string): string
added: function addLocale(path: string, locale?: string | false, defaultLocale?: string): string
added: function delBasePath(path: string): string
added: function delLocale(path: string, locale?: string): string
added: function getDomainLocale(path: string, locale?: string | false, locales?: string[], domainLocales?: DomainLocale[]): string | false
added: function hasBasePath(path: string): boolean
added: function interpolateAs(route: string, asPathname: string, query: ParsedUrlQuery): { params: string[]; result: string }
added: function isLocalURL(url: string): boolean
added: function resolveHref(router: NextRouter, href: Url, resolveAs?: boolean): string
added: method Router._getData<T>(fn: () => Promise<T>): Promise<T>
added: method Router._getServerData(dataHref: string): Promise<object>
added: method Router._getStaticData(dataHref: string): Promise<object>
added: method Router.abortComponentLoad(as: string, routeProps: RouteProperties): void
added: method Router.back(): void
added: method Router.beforePopState(cb: BeforePopStateCallback): void
added: method Router.changeState(method: HistoryMethod, url: string, as: string, options?: TransitionOptions): void
added: method Router.fetchComponent(route: string): Promise<GoodPageCache>
added: method Router.getInitialProps(Component: ComponentType, ctx: NextPageContext): Promise<any>
added: method Router.getRouteInfo(route: string, pathname: string, query: any, as: string, resolvedAs: string, routeProps: RouteProperties): Promise<PrivateRouteInfo>
added: method Router.handleRouteInfoError(err: Error & { code: any; cancelled: boolean }, pathname: string, query: ParsedUrlQuery, as: string, routeProps: RouteProperties, loadErrorFail?: boolean): Promise<CompletePrivateRouteInfo>
added: method Router.notify(data: PrivateRouteInfo, resetScroll: { x: number; y: number } | null): Promise<void>
added: method Router.onlyAHashChange(as: string): boolean
added: method Router.prefetch(url: string, asPath?: string, options?: PrefetchOptions): Promise<void>
added: method Router.push(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>
added: method Router.reload(): void
added: method Router.replace(url: Url, as?: Url, options?: TransitionOptions): Promise<boolean>
added: method Router.scrollToHash(as: string): void
added: method Router.set(route: string, pathname: string, query: ParsedUrlQuery, as: string, data: PrivateRouteInfo, resetScroll: { x: number; y: number } | null): Promise<void>
added: method Router.urlIsNew(asPath: string): boolean
added: property Router._bps: BeforePopStateCallback | undefined
added: property Router._inFlightRoute?: string
added: property Router._shallow?: boolean
added: property Router._wrapApp: (App: AppComponent) => any
added: property Router.asPath: string
added: property Router.basePath: string
added: property Router.clc: ComponentLoadCancel
added: property Router.components: { [pathname: string]: PrivateRouteInfo }
added: property Router.defaultLocale?: string
added: property Router.domainLocales?: DomainLocale[]
added: property Router.events: MittEmitter<RouterEvent>
added: property Router.isFallback: boolean
added: property Router.isLocaleDomain: boolean
added: property Router.isPreview: boolean
added: property Router.isReady: boolean
added: property Router.isSsr: boolean
added: property Router.locale?: string
added: property Router.locales?: string[]
added: property Router.onPopState: (e: PopStateEvent) => void
added: property Router.pageLoader: any
added: property Router.pathname: string
added: property Router.query: ParsedUrlQuery
added: property Router.route: string
added: property Router.sdc: { [asPath: string]: object }
added: property Router.sdr: { [asPath: string]: Promise<object> }
added: property Router.sub: Subscription
added: static property Router.events: MittEmitter<RouterEvent>
added: type AppComponent = ComponentType<AppProps>
added: type AppProps = Pick<CompletePrivateRouteInfo, 'Component' | 'err'> & { router: Router } & Record<string, any>
added: type BaseRouter = { route: string; pathname: string; query: ParsedUrlQuery; asPath: string; basePath: string; locale?: string; locales?: string[]; defaultLocale?: string; domain…
added: type CompletePrivateRouteInfo = { Component: ComponentType; styleSheets: StyleSheetTuple[]; __N_SSG?: boolean; __N_SSP?: boolean; props?: Record<string, any>; err?: Error; error?: any }
added: type NextRouter = BaseRouter & Pick<Router, 'push' | 'replace' | 'reload' | 'back' | 'prefetch' | 'beforePopState' | 'events' | 'isFallback' | 'isReady' | 'isPreview'>
added: type PrefetchOptions = { priority?: boolean; locale?: string | false }
added: type PrivateRouteInfo = (Omit<CompletePrivateRouteInfo, 'styleSheets'> & { initial: true }) | CompletePrivateRouteInfo

added: default function escapePathDelimiters(segment: string, escapeEncoded?: boolean): string

added: function formatUrl(urlObj: UrlObject): string

added: default function getAssetPathFromRoute(route: string, ext?: string): string

added: default function getRouteFromAssetPath(assetPath: string, ext?: string): string

added: export { getRouteMatcher } from './route-matcher'
added: export { getRouteRegex } from './route-regex'
added: export { getSortedRoutes } from './sorted-routes'
added: export { isDynamicRoute } from './is-dynamic'

added: function isDynamicRoute(route: string): boolean

added: function parseNextUrl({ headers, nextConfig, url }: Params): ParsedNextUrl
added: interface ParsedNextUrl extends ParsedUrl
added: property ParsedNextUrl.basePath?: string
added: property ParsedNextUrl.locale?: { defaultLocale: string; domain?: DomainLocale; locale: string; path: PathLocale; redirect?: string; trailingSlash?: boolean }

added: function parseRelativeUrl(url: string, base?: string): { pathname: string; query: import('querystring').ParsedUrlQuery; search: string; hash: string; href: string }

added: function parseUrl(url: string): ParsedUrl
added: interface ParsedUrl
added: property ParsedUrl.hash: string
added: property ParsedUrl.hostname?: string | null
added: property ParsedUrl.href: string
added: property ParsedUrl.pathname: string
added: property ParsedUrl.port?: string | null
added: property ParsedUrl.protocol?: string | null
added: property ParsedUrl.query: ParsedUrlQuery
added: property ParsedUrl.search: string

added: const _default: (customRoute?: boolean) => (path: string, regexModifier?: ((regex: string) => string) | undefined) => (pathname: string | null | undefined, params?: any) => any
added: const customRouteMatcherOptions: pathToRegexp.TokensToRegexpOptions & pathToRegexp.ParseOptions
added: const matcherOptions: pathToRegexp.TokensToRegexpOptions & pathToRegexp.ParseOptions
added: default _default
added: export { pathToRegexp }

added: const getSafeParamName: (paramName: string) => string
added: default function prepareDestination(destination: string, params: Params, query: ParsedUrlQuery, appendParamsToQuery: boolean): { newUrl: string; parsedDestination: import('./parse-url').ParsedUrl }
added: function compileNonPath(value: string, params: Params): string
added: function matchHas(req: IncomingMessage, has: RouteHas[], query: Params): false | Params

added: function assign(target: URLSearchParams, ...searchParamsList: URLSearchParams[]): URLSearchParams
added: function searchParamsToUrlQuery(searchParams: URLSearchParams): ParsedUrlQuery
added: function urlQueryToSearchParams(urlQuery: ParsedUrlQuery): URLSearchParams

added: default function resolveRewrites(asPath: string, pages: string[], rewrites: { beforeFiles: Rewrite[]; afterFiles: Rewrite[]; fallback: Rewrite[] }, query: ParsedUrlQuery, resolveHref: (path: string) => string, locales?: string[]): { matchedPage: boolean; parsedAs: ReturnType<typeof parseRelativeUrl>; asPath: string; resolvedHref?: string }

added: default function resolveRewrites(): void

added: function getRouteMatcher(routeRegex: ReturnType<typeof getRouteRegex>): (pathname: string | null | undefined) => false | { [paramName: string]: string | string[] }

added: function getParametrizedRoute(route: string): { parameterizedRoute: string; namedParameterizedRoute: string; groups: { [groupName: string]: Group }; routeKeys: { [named: string]: string } } | { parameterizedRoute: string; groups: { [groupName: string]: Group }; namedParameterizedRoute?: undefined; routeKeys?: undefined }
added: function getRouteRegex(normalizedRoute: string): RouteRegex
added: interface RouteRegex
added: property RouteRegex.groups: { [groupName: string]: Group }
added: property RouteRegex.namedRegex?: string
added: property RouteRegex.re: RegExp
added: property RouteRegex.routeKeys?: { [named: string]: string }

added: function getSortedRoutes(normalizedPages: string[]): string[]

added: const _default: () => any
added: default _default
added: function setConfig(configValue: any): void

added: constructor extends(props: any)
added: default class extends Component<SideEffectProps>
added: method extends.componentDidMount(): void
added: method extends.componentDidUpdate(): void
added: method extends.componentWillUnmount(): void
added: method extends.render(): null
added: property extends.emitChange: () => void

added: function toBase64(str: string): string

added: class DecodeError extends Error
added: const HtmlContext: import('react').Context<HtmlProps>
added: const SP: boolean
added: const ST: boolean
added: const urlObjectKeys: string[]
added: function execOnce<T extends (...args: any[]) => ReturnType<T>>(fn: T): T
added: function formatWithValidation(url: UrlObject): string
added: function getDisplayName(Component: ComponentType): string
added: function getLocationOrigin(): string
added: function getURL(): string
added: function isResSent(res: ServerResponse): boolean
added: function loadGetInitialProps<C extends BaseContext, IP = {}, P = {}>(App: NextComponentType<C, IP, P>, ctx: C): Promise<IP>
added: function normalizeRepeatedSlashes(url: string): string
added: interface NextApiRequest extends IncomingMessage
added: interface NextPageContext
added: property NextApiRequest.body: any
added: property NextApiRequest.cookies: { [key: string]: string }
added: property NextApiRequest.env: Env
added: property NextApiRequest.preview?: boolean
added: property NextApiRequest.previewData?: PreviewData
added: property NextApiRequest.query: { [key: string]: string | string[] }
added: property NextPageContext.AppTree: AppTreeType
added: property NextPageContext.asPath?: string
added: property NextPageContext.defaultLocale?: string
added: property NextPageContext.err?: (Error & { statusCode?: number }) | null
added: property NextPageContext.locale?: string
added: property NextPageContext.locales?: string[]
added: property NextPageContext.pathname: string
added: property NextPageContext.query: ParsedUrlQuery
added: property NextPageContext.req?: IncomingMessage
added: property NextPageContext.res?: ServerResponse
added: type AppContextType<R extends NextRouter = NextRouter> = { Component: NextComponentType<NextPageContext>; AppTree: AppTreeType; ctx: NextPageContext; router: R }
added: type AppInitialProps = { pageProps: any }
added: type AppPropsType<R extends NextRouter = NextRouter, P = {}> = AppInitialProps & { Component: NextComponentType<NextPageContext, any, P>; router: R; __N_SSG?: boolean; __N_SSP?: boolean }
added: type AppTreeType = ComponentType<AppInitialProps & { [name: string]: any }>
added: type AppType = NextComponentType<AppContextType, AppInitialProps, AppPropsType>
added: type BaseContext = { res?: ServerResponse; [k: string]: any }
added: type ComponentsEnhancer = { enhanceApp?: Enhancer<AppType>; enhanceComponent?: Enhancer<NextComponentType> } | Enhancer<NextComponentType>
added: type DocumentContext = NextPageContext & { renderPage: RenderPage }
added: type DocumentInitialProps = RenderPageResult & { styles?: React.ReactElement[] | React.ReactFragment }
added: type DocumentProps = DocumentInitialProps & HtmlProps
added: type DocumentType = NextComponentType<DocumentContext, DocumentInitialProps, DocumentProps>
added: type Enhancer<C> = (Component: C) => C
added: type HtmlProps = { __NEXT_DATA__: NEXT_DATA; dangerousAsPath: string; docComponentsRendered: { Html?: boolean; Main?: boolean; Head?: boolean; NextScript?: boolean }; buildMani…
added: type NEXT_DATA = { props: Record<string, any>; page: string; query: ParsedUrlQuery; buildId: string; assetPrefix?: string; runtimeConfig?: { [key: string]: any }; nextExport?:…
added: type NextApiHandler<T = any> = (req: NextApiRequest, res: NextApiResponse<T>) => void | Promise<void>
added: type NextApiResponse<T = any> = ServerResponse & { send: Send<T>; json: Send<T>; status: (statusCode: number) => NextApiResponse<T>; redirect(url: string): NextApiResponse<T>; redirect(status…
added: type NextComponentType<C extends BaseContext = NextPageContext, IP = {}, P = {}> = ComponentType & { getInitialProps?(context: C): IP | Promise<IP> }
added: type NextWebVitalsMetric = { id: string; startTime: number; value: number } & ({ label: 'web-vital'; name: 'FCP' | 'LCP' | 'CLS' | 'FID' | 'TTFB' } | { label: 'custom'; name: 'Next.js-hy…
added: type RenderPage = (options?: ComponentsEnhancer) => RenderPageResult | Promise<RenderPageResult>
added: type RenderPageResult = { html: string; head?: Array<JSX.Element | null> }

added: function eventLintCheckCompleted(event: EventLintCheckCompleted): { eventName: string; payload: EventLintCheckCompleted }
added: type EventLintCheckCompleted = { durationInSeconds: number; eslintVersion: string | null; lintedFilesCount?: number; lintFix?: boolean; buildLint?: boolean; nextEslintPluginVersion?: string…

changed: property Telemetry.oneWayHash: (payload: string | DataView | Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array) => string → property Telemetry.oneWayHash: (payload: BinaryLike) => string

removed: function stackPop(keyObj: any, span: any): void
removed: function stackPush(keyObj: any, spanName: string, attrs?: any): Span

removed: export { stackPop }
removed: export { stackPush }
added: export { flushAllTraces }

removed: let report: Reporter
added: const reporter: MultiReporter

removed: const reportToConsole: (spanName: string, duration: number, _timestamp: number, id: string, parentId?: string | undefined, attrs?: Object | undefined) => void
removed: default reportToConsole
added: const _default: { flushAll: () => void; report: (spanName: string, duration: number, _timestamp: number, id: string, parentId?: string | undefined, attrs?: Object | undefined)…
added: default _default

added: const _default: { flushAll: () => Promise<void> | undefined; report: (name: string, duration: number, timestamp: number, id: string, parentId?: string | undefined, attrs?: Obj…
added: default _default

added: const _default: { flushAll: () => Promise<void> | undefined; report: (name: string, duration: number, timestamp: number, id: string, parentId?: string | undefined, attrs?: Obj…
added: default _default

removed: const reportToTelemetry: (spanName: string, duration: number) => void
removed: default reportToTelemetry
added: const _default: { flushAll: () => void; report: (spanName: string, duration: number) => void }
added: default _default

removed: const reportToLocalHost: (name: string, duration: number, timestamp: number, id: string, parentId?: string | undefined, attrs?: Object | undefined) => void
removed: default reportToLocalHost
added: const _default: { flushAll: () => Promise<void> | undefined; report: (name: string, duration: number, timestamp: number, id: string, parentId?: string | undefined, attrs?: Obj…
added: default _default
added: function batcher(reportEvents: (evts: Event[]) => Promise<void>): { flushAll: () => Promise<void>; report: (event: Event) => void }

changed: const debugLog: { (message?: any, ...optionalParams: any[]): void; (message?: any, ...optionalParams: any[]): void } → const debugLog: { (...data: any[]): void; (message?: any, ...optionalParams: any[]): void }
added: member TARGET.JAEGER = 'JAEGER'

added: const flushAllTraces: () => Promise<void>

removed: export * from './dist/next-server/lib/dynamic'
removed: export { default } from './dist/next-server/lib/dynamic'
added: export * from './dist/shared/lib/dynamic'
added: export { default } from './dist/shared/lib/dynamic'

removed: export * from './dist/client/experimental-script'
removed: export { default } from './dist/client/experimental-script'

removed: export * from './dist/next-server/lib/head'
removed: export { default } from './dist/next-server/lib/head'
added: export * from './dist/shared/lib/head'
added: export { default } from './dist/shared/lib/head'

added: declare module '*.bmp'
added: declare module '*.gif'
added: declare module '*.ico'
added: declare module '*.jpeg'
added: declare module '*.jpg'
added: declare module '*.png'
added: declare module '*.svg'
added: declare module '*.webp'
added: interface StaticImageData
added: property StaticImageData.blurDataURL?: string
added: property StaticImageData.height: number
added: property StaticImageData.src: string
added: property StaticImageData.width: number

added: export * from './dist/client/script'
added: export { default } from './dist/client/script'

changed: type GetStaticPaths = (context: GetStaticPathsContext) => Promise<GetStaticPathsResult> → type GetStaticPaths = (context: GetStaticPathsContext) => Promise<GetStaticPathsResult> | GetStaticPathsResult
changed: type GetStaticProps = (context: GetStaticPropsContext<Q>) => Promise<GetStaticPropsResult> → type GetStaticProps = (context: GetStaticPropsContext<Q>) => Promise<GetStaticPropsResult> | GetStaticPropsResult
changed: type InferGetStaticPropsType<T> = T extends GetStaticProps<infer P, any> ? P : T extends (context?: GetStaticPropsContext<any>) => Promise<GetStaticPropsResult<infer P>> ? P : never → type InferGetStaticPropsType<T> = T extends GetStaticProps<infer P, any> ? P : T extends (context?: GetStaticPropsContext<any>) => Promise<GetStaticPropsResult<infer P>> | GetStaticPropsResult<…
added: type NextConfig = NextConfigType