.

node_modules/next/dist/server/route-modules/route-module.d.ts

@@ -0,0 +1,132 @@
+import '../../build/adapter/setup-node-env.external';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { InstrumentationOnRequestError, RequestErrorContext } from '../instrumentation/types';
+import type { ParsedUrlQuery } from 'node:querystring';
+import type { UrlWithParsedQuery } from 'node:url';
+import type { PrerenderManifest, RequiredServerFilesManifest } from '../../build';
+import type { DevRoutesManifest } from '../lib/router-utils/setup-dev-bundler';
+import type { RouteDefinition } from '../route-definitions/route-definition';
+import type { DeepReadonly } from '../../shared/lib/deep-readonly';
+import type { PreviewData } from '../../types';
+import type { BuildManifest } from '../get-page-files';
+import type { ReactLoadableManifest } from '../load-components';
+import type { NextFontManifest } from '../../build/webpack/plugins/next-font-manifest-plugin';
+import { type NextIncomingMessage } from '../request-meta';
+import { IncrementalCache } from '../lib/incremental-cache';
+import { RouteKind } from '../route-kind';
+import type { BaseNextRequest } from '../base-http';
+import type { NextConfigRuntime } from '../config-shared';
+import ResponseCache, { type ResponseGenerator } from '../response-cache';
+import { type RouterServerContext } from '../lib/router-utils/router-server-context';
+/**
+ * RouteModuleOptions is the options that are passed to the route module, other
+ * route modules should extend this class to add specific options for their
+ * route.
+ */
+export interface RouteModuleOptions<D extends RouteDefinition = RouteDefinition, U = unknown> {
+    readonly definition: Readonly<D>;
+    readonly userland: Readonly<U>;
+    readonly distDir: string;
+    readonly relativeProjectDir: string;
+}
+/**
+ * RouteHandlerContext is the base context for a route handler.
+ */
+export interface RouteModuleHandleContext {
+    /**
+     * Any matched parameters for the request. This is only defined for dynamic
+     * routes.
+     */
+    params: Record<string, string | string[] | undefined> | undefined;
+}
+/**
+ * RouteModule is the base class for all route modules. This class should be
+ * extended by all route modules.
+ */
+export declare abstract class RouteModule<D extends RouteDefinition = RouteDefinition, U = unknown> {
+    /**
+     * The userland module. This is the module that is exported from the user's
+     * code. This is marked as readonly to ensure that the module is not mutated
+     * because the module (when compiled) only provides getters.
+     */
+    readonly userland: Readonly<U>;
+    /**
+     * The definition of the route.
+     */
+    readonly definition: Readonly<D>;
+    /**
+     * The shared modules that are exposed and required for the route module.
+     */
+    static readonly sharedModules: any;
+    isDev: boolean;
+    distDir: string;
+    relativeProjectDir: string;
+    incrementCache?: IncrementalCache;
+    responseCache?: ResponseCache;
+    constructor({ userland, definition, distDir, relativeProjectDir, }: RouteModuleOptions<D, U>);
+    private getRouterServerContext;
+    normalizeUrl(_req: IncomingMessage | BaseNextRequest, _parsedUrl: UrlWithParsedQuery): void;
+    instrumentationOnRequestError(req: IncomingMessage | BaseNextRequest, ...args: Parameters<InstrumentationOnRequestError>): Promise<void>;
+    private loadManifests;
+    loadCustomCacheHandlers(req: IncomingMessage | BaseNextRequest, nextConfig: NextConfigRuntime): Promise<void>;
+    getIncrementalCache(req: IncomingMessage | BaseNextRequest, nextConfig: NextConfigRuntime, prerenderManifest: DeepReadonly<PrerenderManifest>, isMinimalMode: boolean): Promise<IncrementalCache>;
+    onRequestError(req: IncomingMessage | BaseNextRequest, err: unknown, errorContext: RequestErrorContext, silenceLog: boolean, routerServerContext?: RouterServerContext[string]): Promise<void>;
+    /** A more lightweight version of `prepare()` for only retrieving the config on edge */
+    getNextConfigEdge(req: NextIncomingMessage): {
+        nextConfig: NextConfigRuntime;
+        deploymentId: string;
+    };
+    prepare(req: IncomingMessage | BaseNextRequest, res: ServerResponse | null, { srcPage, multiZoneDraftMode, }: {
+        srcPage: string;
+        multiZoneDraftMode?: boolean;
+    }): Promise<{
+        buildId: string;
+        deploymentId: string;
+        clientAssetToken: string;
+        locale?: string;
+        locales?: readonly string[];
+        defaultLocale?: string;
+        query: ParsedUrlQuery;
+        originalQuery: ParsedUrlQuery;
+        originalPathname: string;
+        params?: ParsedUrlQuery;
+        parsedUrl: UrlWithParsedQuery;
+        previewData: PreviewData;
+        pageIsDynamic: boolean;
+        isDraftMode: boolean;
+        resolvedPathname: string;
+        encodedResolvedPathname: string;
+        isNextDataRequest: boolean;
+        buildManifest: DeepReadonly<BuildManifest>;
+        fallbackBuildManifest: DeepReadonly<BuildManifest>;
+        nextFontManifest: DeepReadonly<NextFontManifest>;
+        serverFilesManifest: DeepReadonly<RequiredServerFilesManifest> | undefined;
+        reactLoadableManifest: DeepReadonly<ReactLoadableManifest>;
+        routesManifest: DeepReadonly<DevRoutesManifest>;
+        prerenderManifest: DeepReadonly<PrerenderManifest>;
+        clientReferenceManifest?: any;
+        serverActionsManifest?: any;
+        dynamicCssManifest?: any;
+        subresourceIntegrityManifest?: DeepReadonly<Record<string, string>>;
+        isOnDemandRevalidate: boolean;
+        revalidateOnlyGenerated: boolean;
+        nextConfig: NextConfigRuntime;
+        routerServerContext?: RouterServerContext[string];
+        interceptionRoutePatterns?: any;
+    } | undefined>;
+    getResponseCache(req: IncomingMessage | BaseNextRequest): ResponseCache;
+    handleResponse({ req, nextConfig, cacheKey, routeKind, isFallback, prerenderManifest, isRoutePPREnabled, isOnDemandRevalidate, revalidateOnlyGenerated, responseGenerator, waitUntil, isMinimalMode, }: {
+        req: IncomingMessage | BaseNextRequest;
+        nextConfig: NextConfigRuntime;
+        cacheKey: string | null;
+        routeKind: RouteKind;
+        isFallback?: boolean;
+        prerenderManifest: DeepReadonly<PrerenderManifest>;
+        isRoutePPREnabled?: boolean;
+        isOnDemandRevalidate?: boolean;
+        revalidateOnlyGenerated?: boolean;
+        responseGenerator: ResponseGenerator;
+        waitUntil?: (prom: Promise<any>) => void;
+        isMinimalMode: boolean;
+    }): Promise<import("../response-cache").ResponseCacheEntry | null>;
+}