@opennextjs/aws 3.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 SST
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,94 @@
+<p align="center">
+  <a href="https://open-next.js.org">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="docs/public/logo-dark.svg">
+      <img alt="OpenNext" src="docs/public/logo-light.svg" width="300" />
+    </picture>
+  </a>
+</p>
+<p align="center">
+  <a href="https://sst.dev/discord"><img alt="Discord" src="https://img.shields.io/discord/983865673656705025?style=flat-square" /></a>
+  <a href="https://www.npmjs.com/package/open-next"><img alt="npm" src="https://img.shields.io/npm/v/open-next.svg?style=flat-square" /></a>
+</p>
+
+---
+
+<p align="center">
+  <a href="https://open-next.js.org/">Docs</a> |
+  <a href="#example">Example</a> 
+</p>
+
+OpenNext takes the Next.js build output and converts it into a package that can be deployed to any functions as a service platform.
+
+## Features
+
+OpenNext aims to support all Next.js 14 features. Some features are work in progress. Please open a [new issue](/issues/new) to let us know!
+
+- [x] App & Pages Router
+- [x] API routes
+- [x] Dynamic routes
+- [x] Static site generation (SSG)
+- [x] Server-side rendering (SSR)
+- [x] Incremental static regeneration (ISR)
+- [x] Middleware
+- [x] Image optimization
+- [x] [NextAuth.js](https://next-auth.js.org)
+- [x] Running at edge
+- [x] No cold start
+
+## Who is using OpenNext?
+
+[Gymshark UK](https://uk.gymshark.com), [Udacity](https://engineering.udacity.com/deploying-next-js-on-the-edge-with-sst-is-sst-the-game-changer-its-claimed-to-be-1f05a0abc27c), [TUDN](https://www.tudn.com), [NHS England](https://github.com/nhs-england-tools/terraform-aws-opennext)
+
+
+
+## Example
+
+In the `example` folder, you can find a Next.js benchmark app. It contains a variety of pages that each test a single Next.js feature. The app is deployed to both Vercel and AWS using [SST](https://docs.sst.dev/start/nextjs).
+
+AWS link: https://d1gwt3w78t4dm3.cloudfront.net
+
+Vercel link: https://open-next.vercel.app
+
+## Configuration
+
+### Environment variables
+
+- AWS_SDK_DYNAMODB_MAX_ATTEMPTS: The maximum number of times requests that encounter retryable failures should be attempted for DynamoDB. Defaults to 3.
+- AWS_SDK_S3_MAX_ATTEMPTS: The maximum number of times requests that encounter retryable failures should be attempted for S3. Defaults to 3.
+- DYNAMO_BATCH_WRITE_COMMAND_CONCURRENCY: The number of concurrent batch write commands to DynamoDB. Defaults to 4 in an effort to leave plenty of DynamoDB write request capacity for the production load.
+
+## Contribute
+
+To run `OpenNext` locally:
+
+1. Clone this repository.
+1. Build `open-next`:
+   ```bash
+   cd open-next
+   pnpm build
+   ```
+1. Run `open-next` in watch mode:
+   ```bash
+   pnpm dev
+   ```
+1. Now, you can make changes in `open-next` and build your Next.js app to test the changes.
+   ```bash
+   cd path/to/my/nextjs/app
+   path/to/open-next/packages/open-next/dist/index.js build
+   ```
+
+## Acknowledgements
+
+We are grateful for the projects that inspired OpenNext and the amazing tools and libraries developed by the community:
+
+- [nextjs-lambda](https://github.com/sladg/nextjs-lambda) by [Jan](https://github.com/sladg) for serving as inspiration for packaging Next.js's standalone output to Lambda.
+- [CDK NextJS](https://github.com/jetbridge/cdk-nextjs/) by [JetBridge](https://github.com/jetbridge) for its contribution to the deployment architecture of a Next.js application on AWS.
+- [serverless-http](https://github.com/dougmoscrop/serverless-http) by [Doug Moscrop](https://github.com/dougmoscrop) for developing an excellent library for transforming AWS Lambda events and responses.
+- [serverless-nextjs](https://github.com/serverless-nextjs/serverless-next.js) by [Serverless Framework](https://github.com/serverless) for paving the way for serverless Next.js applications on AWS.
+
+Special shoutout to [@khuezy](https://github.com/khuezy) and [@conico974](https://github.com/conico974) for their outstanding contributions to the project.
+
+---
+
+Maintained by [SST](https://sst.dev). Join our community: [Discord](https://sst.dev/discord) | [YouTube](https://www.youtube.com/c/sst-dev) | [Twitter](https://twitter.com/SST_dev)

package/dist/adapters/binary.d.ts

@@ -0,0 +1 @@
+export declare function isBinaryContentType(contentType?: string | null): boolean;

package/dist/adapters/binary.js

@@ -0,0 +1,63 @@
+const commonBinaryMimeTypes = new Set([
+    "application/octet-stream",
+    // Docs
+    "application/epub+zip",
+    "application/msword",
+    "application/pdf",
+    "application/rtf",
+    "application/vnd.amazon.ebook",
+    "application/vnd.ms-excel",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    // Fonts
+    "font/otf",
+    "font/woff",
+    "font/woff2",
+    // Images
+    "image/bmp",
+    "image/gif",
+    "image/jpeg",
+    "image/png",
+    "image/tiff",
+    "image/vnd.microsoft.icon",
+    "image/webp",
+    // Audio
+    "audio/3gpp",
+    "audio/aac",
+    "audio/basic",
+    "audio/mpeg",
+    "audio/ogg",
+    "audio/wavaudio/webm",
+    "audio/x-aiff",
+    "audio/x-midi",
+    "audio/x-wav",
+    // Video
+    "video/3gpp",
+    "video/mp2t",
+    "video/mpeg",
+    "video/ogg",
+    "video/quicktime",
+    "video/webm",
+    "video/x-msvideo",
+    // Archives
+    "application/java-archive",
+    "application/vnd.apple.installer+xml",
+    "application/x-7z-compressed",
+    "application/x-apple-diskimage",
+    "application/x-bzip",
+    "application/x-bzip2",
+    "application/x-gzip",
+    "application/x-java-archive",
+    "application/x-rar-compressed",
+    "application/x-tar",
+    "application/x-zip",
+    "application/zip",
+]);
+export function isBinaryContentType(contentType) {
+    if (!contentType)
+        return false;
+    const value = contentType?.split(";")[0] ?? "";
+    return commonBinaryMimeTypes.has(value);
+}

package/dist/adapters/cache.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { IncrementalCache } from "../cache/incremental/types.js";
+import { TagCache } from "../cache/tag/types.js";
+interface CachedFetchValue {
+    kind: "FETCH";
+    data: {
+        headers: {
+            [k: string]: string;
+        };
+        body: string;
+        url: string;
+        status?: number;
+        tags?: string[];
+    };
+    revalidate: number;
+}
+interface CachedRedirectValue {
+    kind: "REDIRECT";
+    props: Object;
+}
+interface CachedRouteValue {
+    kind: "ROUTE" | "APP_ROUTE";
+    body: Buffer;
+    status: number;
+    headers: Record<string, undefined | string | string[]>;
+}
+interface CachedImageValue {
+    kind: "IMAGE";
+    etag: string;
+    buffer: Buffer;
+    extension: string;
+    isMiss?: boolean;
+    isStale?: boolean;
+}
+interface IncrementalCachedPageValue {
+    kind: "PAGE" | "PAGES";
+    html: string;
+    pageData: Object;
+    status?: number;
+    headers?: Record<string, undefined | string>;
+}
+interface IncrementalCachedAppPageValue {
+    kind: "APP_PAGE";
+    html: string;
+    rscData: Buffer;
+    headers?: Record<string, undefined | string | string[]>;
+    postponed?: string;
+    status?: number;
+}
+type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | IncrementalCachedAppPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
+type IncrementalCacheContext = {
+    revalidate?: number | false | undefined;
+    fetchCache?: boolean | undefined;
+    fetchUrl?: string | undefined;
+    fetchIdx?: number | undefined;
+    tags?: string[] | undefined;
+};
+interface CacheHandlerContext {
+    fs?: never;
+    dev?: boolean;
+    flushToDisk?: boolean;
+    serverDistDir?: string;
+    maxMemoryCacheSize?: number;
+    _appDir: boolean;
+    _requestHeaders: never;
+    fetchCacheKeyPrefix?: string;
+}
+interface CacheHandlerValue {
+    lastModified?: number;
+    age?: number;
+    cacheState?: string;
+    value: IncrementalCacheValue | null;
+}
+export declare function hasCacheExtension(key: string): boolean;
+declare global {
+    var incrementalCache: IncrementalCache;
+    var tagCache: TagCache;
+    var disableDynamoDBCache: boolean;
+    var disableIncrementalCache: boolean;
+    var lastModified: Record<string, number>;
+    var isNextAfter15: boolean;
+}
+export default class S3Cache {
+    constructor(_ctx: CacheHandlerContext);
+    get(key: string, options?: boolean | {
+        fetchCache?: boolean;
+        kindHint?: "app" | "pages" | "fetch";
+        tags?: string[];
+        softTags?: string[];
+    }): Promise<CacheHandlerValue | null>;
+    getFetchCache(key: string, softTags?: string[], tags?: string[]): Promise<CacheHandlerValue | null>;
+    getIncrementalCache(key: string): Promise<CacheHandlerValue | null>;
+    set(key: string, data?: IncrementalCacheValue, ctx?: IncrementalCacheContext): Promise<void>;
+    revalidateTag(tags: string | string[]): Promise<void>;
+}
+export {};

package/dist/adapters/cache.js

@@ -0,0 +1,278 @@
+import { isBinaryContentType } from "./binary.js";
+import { debug, error, warn } from "./logger.js";
+/** Beginning single backslash is intentional, to look for the dot + the extension. Do not escape it again. */
+const CACHE_EXTENSION_REGEX = /\.(cache|fetch)$/;
+export function hasCacheExtension(key) {
+    return CACHE_EXTENSION_REGEX.test(key);
+}
+// We need to use globalThis client here as this class can be defined at load time in next 12 but client is not available at load time
+export default class S3Cache {
+    constructor(_ctx) { }
+    async get(key, 
+    // fetchCache is for next 13.5 and above, kindHint is for next 14 and above and boolean is for earlier versions
+    options) {
+        if (globalThis.disableIncrementalCache) {
+            return null;
+        }
+        const isFetchCache = typeof options === "object"
+            ? options.kindHint
+                ? options.kindHint === "fetch"
+                : options.fetchCache
+            : options;
+        const softTags = typeof options === "object" ? options.softTags : [];
+        const tags = typeof options === "object" ? options.tags : [];
+        return isFetchCache
+            ? this.getFetchCache(key, softTags, tags)
+            : this.getIncrementalCache(key);
+    }
+    async getFetchCache(key, softTags, tags) {
+        debug("get fetch cache", { key, softTags, tags });
+        try {
+            const { value, lastModified } = await globalThis.incrementalCache.get(key, true);
+            // const { Body, LastModified } = await this.getS3Object(key, "fetch");
+            const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
+            if (_lastModified === -1) {
+                // If some tags are stale we need to force revalidation
+                return null;
+            }
+            if (value === undefined)
+                return null;
+            // For cases where we don't have tags, we need to ensure that the soft tags are not being revalidated
+            // We only need to check for the path as it should already contain all the tags
+            if ((tags ?? []).length === 0) {
+                // Then we need to find the path for the given key
+                const path = softTags?.find((tag) => tag.startsWith("_N_T_/") &&
+                    !tag.endsWith("layout") &&
+                    !tag.endsWith("page"));
+                if (path) {
+                    const pathLastModified = await globalThis.tagCache.getLastModified(path.replace("_N_T_/", ""), lastModified);
+                    if (pathLastModified === -1) {
+                        // In case the path has been revalidated, we don't want to use the fetch cache
+                        return null;
+                    }
+                }
+            }
+            return {
+                lastModified: _lastModified,
+                value: value,
+            };
+        }
+        catch (e) {
+            // We can usually ignore errors here as they are usually due to cache not being found
+            debug("Failed to get fetch cache", e);
+            return null;
+        }
+    }
+    async getIncrementalCache(key) {
+        try {
+            const { value: cacheData, lastModified } = await globalThis.incrementalCache.get(key, false);
+            // const { Body, LastModified } = await this.getS3Object(key, "cache");
+            // const cacheData = JSON.parse(
+            //   (await Body?.transformToString()) ?? "{}",
+            // ) as S3CachedFile;
+            const meta = cacheData?.meta;
+            const _lastModified = await globalThis.tagCache.getLastModified(key, lastModified);
+            if (_lastModified === -1) {
+                // If some tags are stale we need to force revalidation
+                return null;
+            }
+            const requestId = globalThis.__als.getStore()?.requestId ?? "";
+            globalThis.lastModified[requestId] = _lastModified;
+            if (cacheData?.type === "route") {
+                return {
+                    lastModified: _lastModified,
+                    value: {
+                        kind: globalThis.isNextAfter15 ? "APP_ROUTE" : "ROUTE",
+                        body: Buffer.from(cacheData.body ?? Buffer.alloc(0), isBinaryContentType(String(meta?.headers?.["content-type"]))
+                            ? "base64"
+                            : "utf8"),
+                        status: meta?.status,
+                        headers: meta?.headers,
+                    },
+                };
+            }
+            else if (cacheData?.type === "page" || cacheData?.type === "app") {
+                if (globalThis.isNextAfter15 && cacheData?.type === "app") {
+                    return {
+                        lastModified: _lastModified,
+                        value: {
+                            kind: "APP_PAGE",
+                            html: cacheData.html,
+                            rscData: Buffer.from(cacheData.rsc),
+                            status: meta?.status,
+                            headers: meta?.headers,
+                        },
+                    };
+                }
+                return {
+                    lastModified: _lastModified,
+                    value: {
+                        kind: globalThis.isNextAfter15 ? "PAGES" : "PAGE",
+                        html: cacheData.html,
+                        pageData: cacheData.type === "page" ? cacheData.json : cacheData.rsc,
+                        status: meta?.status,
+                        headers: meta?.headers,
+                    },
+                };
+            }
+            else if (cacheData?.type === "redirect") {
+                return {
+                    lastModified: _lastModified,
+                    value: {
+                        kind: "REDIRECT",
+                        props: cacheData.props,
+                    },
+                };
+            }
+            else {
+                warn("Unknown cache type", cacheData);
+                return null;
+            }
+        }
+        catch (e) {
+            // We can usually ignore errors here as they are usually due to cache not being found
+            debug("Failed to get body cache", e);
+            return null;
+        }
+    }
+    async set(key, data, ctx) {
+        if (globalThis.disableIncrementalCache) {
+            return;
+        }
+        // This one might not even be necessary anymore
+        // Better be safe than sorry
+        const detachedPromise = globalThis.__als
+            .getStore()
+            ?.pendingPromiseRunner.withResolvers();
+        try {
+            if (data?.kind === "ROUTE" || data?.kind === "APP_ROUTE") {
+                const { body, status, headers } = data;
+                await globalThis.incrementalCache.set(key, {
+                    type: "route",
+                    body: body.toString(isBinaryContentType(String(headers["content-type"]))
+                        ? "base64"
+                        : "utf8"),
+                    meta: {
+                        status,
+                        headers,
+                    },
+                }, false);
+            }
+            else if (data?.kind === "PAGE" || data?.kind === "PAGES") {
+                const { html, pageData, status, headers } = data;
+                const isAppPath = typeof pageData === "string";
+                if (isAppPath) {
+                    await globalThis.incrementalCache.set(key, {
+                        type: "app",
+                        html,
+                        rsc: pageData,
+                        meta: {
+                            status,
+                            headers,
+                        },
+                    }, false);
+                }
+                else {
+                    await globalThis.incrementalCache.set(key, {
+                        type: "page",
+                        html,
+                        json: pageData,
+                    }, false);
+                }
+            }
+            else if (data?.kind === "APP_PAGE") {
+                const { html, rscData, headers, status } = data;
+                await globalThis.incrementalCache.set(key, {
+                    type: "app",
+                    html,
+                    rsc: rscData.toString("utf8"),
+                    meta: {
+                        status,
+                        headers,
+                    },
+                }, false);
+            }
+            else if (data?.kind === "FETCH") {
+                await globalThis.incrementalCache.set(key, data, true);
+            }
+            else if (data?.kind === "REDIRECT") {
+                await globalThis.incrementalCache.set(key, {
+                    type: "redirect",
+                    props: data.props,
+                }, false);
+            }
+            else if (data === null || data === undefined) {
+                await globalThis.incrementalCache.delete(key);
+            }
+            // Write derivedTags to dynamodb
+            // If we use an in house version of getDerivedTags in build we should use it here instead of next's one
+            const derivedTags = data?.kind === "FETCH"
+                ? ctx?.tags ?? data?.data?.tags ?? [] // before version 14 next.js used data?.data?.tags so we keep it for backward compatibility
+                : data?.kind === "PAGE"
+                    ? data.headers?.["x-next-cache-tags"]?.split(",") ?? []
+                    : [];
+            debug("derivedTags", derivedTags);
+            // Get all tags stored in dynamodb for the given key
+            // If any of the derived tags are not stored in dynamodb for the given key, write them
+            const storedTags = await globalThis.tagCache.getByPath(key);
+            const tagsToWrite = derivedTags.filter((tag) => !storedTags.includes(tag));
+            if (tagsToWrite.length > 0) {
+                await globalThis.tagCache.writeTags(tagsToWrite.map((tag) => ({
+                    path: key,
+                    tag: tag,
+                    // In case the tags are not there we just need to create them
+                    // but we don't want them to return from `getLastModified` as they are not stale
+                    revalidatedAt: 1,
+                })));
+            }
+            debug("Finished setting cache");
+        }
+        catch (e) {
+            error("Failed to set cache", e);
+        }
+        finally {
+            // We need to resolve the promise even if there was an error
+            detachedPromise?.resolve();
+        }
+    }
+    async revalidateTag(tags) {
+        if (globalThis.disableDynamoDBCache || globalThis.disableIncrementalCache) {
+            return;
+        }
+        try {
+            const _tags = Array.isArray(tags) ? tags : [tags];
+            for (const tag of _tags) {
+                debug("revalidateTag", tag);
+                // Find all keys with the given tag
+                const paths = await globalThis.tagCache.getByTag(tag);
+                debug("Items", paths);
+                const toInsert = paths.map((path) => ({
+                    path,
+                    tag,
+                }));
+                // If the tag is a soft tag, we should also revalidate the hard tags
+                if (tag.startsWith("_N_T_/")) {
+                    for (const path of paths) {
+                        // We need to find all hard tags for a given path
+                        const _tags = await globalThis.tagCache.getByPath(path);
+                        const hardTags = _tags.filter((t) => !t.startsWith("_N_T_/"));
+                        // For every hard tag, we need to find all paths and revalidate them
+                        for (const hardTag of hardTags) {
+                            const _paths = await globalThis.tagCache.getByTag(hardTag);
+                            debug({ hardTag, _paths });
+                            toInsert.push(..._paths.map((path) => ({
+                                path,
+                                tag: hardTag,
+                            })));
+                        }
+                    }
+                }
+                // Update all keys with the given tag with revalidatedAt set to now
+                await globalThis.tagCache.writeTags(toInsert);
+            }
+        }
+        catch (e) {
+            error("Failed to revalidate tag", e);
+        }
+    }
+}

package/dist/adapters/config/index.d.ts

@@ -0,0 +1,27 @@
+export declare const NEXT_DIR: string;
+export declare const OPEN_NEXT_DIR: string;
+export declare const NextConfig: import("../../types/next-types").NextConfig;
+export declare const BuildId: string;
+export declare const HtmlPages: string[];
+export declare const RoutesManifest: {
+    basePath: string | undefined;
+    rewrites: {
+        beforeFiles: import("../../types/next-types").RewriteDefinition[];
+        afterFiles: import("../../types/next-types").RewriteDefinition[];
+        fallback: import("../../types/next-types").RewriteDefinition[];
+    };
+    redirects: import("../../types/next-types").RedirectDefinition[];
+    routes: {
+        static: import("../../types/next-types").RouteDefinition[];
+        dynamic: import("../../types/next-types").RouteDefinition[];
+        data: {
+            static: import("../../types/next-types").DataRouteDefinition[];
+            dynamic: import("../../types/next-types").DataRouteDefinition[];
+        };
+    };
+    locales: string[];
+};
+export declare const ConfigHeaders: import("../../types/next-types").Header[] | undefined;
+export declare const PrerenderManifest: import("../../types/next-types").PrerenderManifest;
+export declare const AppPathsManifestKeys: string[];
+export declare const MiddlewareManifest: import("../../types/next-types").MiddlewareManifest;

package/dist/adapters/config/index.js

@@ -0,0 +1,21 @@
+import path from "path";
+import { debug } from "../logger";
+import { loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, 
+// loadPublicAssets,
+loadRoutesManifest, } from "./util.js";
+export const NEXT_DIR = path.join(__dirname, ".next");
+export const OPEN_NEXT_DIR = path.join(__dirname, ".open-next");
+debug({ NEXT_DIR, OPEN_NEXT_DIR });
+//TODO: inject these values at build time
+export const NextConfig = /* @__PURE__ */ loadConfig(NEXT_DIR);
+export const BuildId = /* @__PURE__ */ loadBuildId(NEXT_DIR);
+export const HtmlPages = /* @__PURE__ */ loadHtmlPages(NEXT_DIR);
+// export const PublicAssets = loadPublicAssets(OPEN_NEXT_DIR);
+export const RoutesManifest = /* @__PURE__ */ loadRoutesManifest(NEXT_DIR);
+export const ConfigHeaders = /* @__PURE__ */ loadConfigHeaders(NEXT_DIR);
+export const PrerenderManifest = 
+/* @__PURE__ */ loadPrerenderManifest(NEXT_DIR);
+export const AppPathsManifestKeys = 
+/* @__PURE__ */ loadAppPathsManifestKeys(NEXT_DIR);
+export const MiddlewareManifest = 
+/* @__PURE__ */ loadMiddlewareManifest(NEXT_DIR);

package/dist/adapters/config/util.d.ts

@@ -0,0 +1,28 @@
+import { MiddlewareManifest, NextConfig, PrerenderManifest } from "../../types/next-types";
+import { PublicFiles } from "../../build";
+export declare function loadConfig(nextDir: string): NextConfig;
+export declare function loadBuildId(nextDir: string): string;
+export declare function loadHtmlPages(nextDir: string): string[];
+export declare function loadPublicAssets(openNextDir: string): PublicFiles;
+export declare function loadRoutesManifest(nextDir: string): {
+    basePath: string | undefined;
+    rewrites: {
+        beforeFiles: import("../../types/next-types").RewriteDefinition[];
+        afterFiles: import("../../types/next-types").RewriteDefinition[];
+        fallback: import("../../types/next-types").RewriteDefinition[];
+    };
+    redirects: import("../../types/next-types").RedirectDefinition[];
+    routes: {
+        static: import("../../types/next-types").RouteDefinition[];
+        dynamic: import("../../types/next-types").RouteDefinition[];
+        data: {
+            static: import("../../types/next-types").DataRouteDefinition[];
+            dynamic: import("../../types/next-types").DataRouteDefinition[];
+        };
+    };
+    locales: string[];
+};
+export declare function loadConfigHeaders(nextDir: string): import("../../types/next-types").Header[] | undefined;
+export declare function loadPrerenderManifest(nextDir: string): PrerenderManifest;
+export declare function loadAppPathsManifestKeys(nextDir: string): string[];
+export declare function loadMiddlewareManifest(nextDir: string): MiddlewareManifest;