--- NOTE: do not edit this file, it is generated in apps/svelte.dev/scripts/sync-docs/index.ts title: @sveltejs/kit --- ```js // @noErrors import { Server, VERSION, error, fail, isActionFailure, isHttpError, isRedirect, json, normalizeUrl, redirect, text } from '@sveltejs/kit'; ``` ## Server

```dts class Server {/*…*/} ```

```dts constructor(manifest: SSRManifest); ```

```dts init(options: ServerInitOptions): Promise; ```

```dts respond(request: Request, options: RequestOptions): Promise; ```

## VERSION

```dts const VERSION: string; ```

## error Throws an error with a HTTP status code and an optional message. When called during request handling, this will cause SvelteKit to return an error response without invoking `handleError`. Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.

```dts function error(status: number, body: App.Error): never; ```

```dts function error( status: number, body?: { message: string; } extends App.Error ? App.Error | string | undefined : never ): never; ```

## fail Create an `ActionFailure` object. Call when form submission fails.

```dts function fail(status: number): ActionFailure; ```

```dts function fail( status: number, data: T ): ActionFailure; ```

## isActionFailure Checks whether this is an action failure thrown by `fail`.

```dts function isActionFailure(e: unknown): e is ActionFailure; ```

## isHttpError Checks whether this is an error thrown by `error`.

```dts function isHttpError( e: unknown, status?: T ): e is HttpError_1 & { status: T extends undefined ? never : T; }; ```

## isRedirect Checks whether this is a redirect thrown by `redirect`.

```dts function isRedirect(e: unknown): e is Redirect_1; ```

## json Create a JSON `Response` object from the supplied data.

```dts function json(data: any, init?: ResponseInit): Response; ```

## normalizeUrl

Available since 2.18.0

Strips possible SvelteKit-internal suffixes and trailing slashes from the URL pathname. Returns the normalized URL as well as a method for adding the potential suffix back based on a new pathname (possibly including search) or URL. ```js // @errors: 7031 import { normalizeUrl } from '@sveltejs/kit'; const { url, denormalize } = normalizeUrl('/blog/post/__data.json'); console.log(url.pathname); // /blog/post console.log(denormalize('/blog/post/a')); // /blog/post/a/__data.json ```

```dts function normalizeUrl(url: URL | string): { url: URL; wasNormalized: boolean; denormalize: (url?: string | URL) => URL; }; ```

## redirect Redirect a request. When called during request handling, SvelteKit will return a redirect response. Make sure you're not catching the thrown redirect, which would prevent SvelteKit from handling it. Most common status codes: * `303 See Other`: redirect as a GET request (often used after a form POST request) * `307 Temporary Redirect`: redirect will keep the request method * `308 Permanent Redirect`: redirect will keep the request method, SEO will be transferred to the new page [See all redirect status codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages)

```dts function redirect( status: | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL ): never; ```

## text Create a `Response` object from the supplied body.

```dts function text(body: string, init?: ResponseInit): Response; ```

## Action Shape of a form action method that is part of `export const actions = {...}` in `+page.server.js`. See [form actions](/docs/kit/form-actions) for more information.

```dts type Action< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, OutputData extends Record | void = Record< string, any > | void, RouteId extends AppRouteId | null = AppRouteId | null > = ( event: RequestEvent ) => MaybePromise; ```

## ActionFailure

```dts interface ActionFailure {/*…*/} ```

```dts status: number; ```

```dts data: T; ```

```dts [uniqueSymbol]: true; ```

## ActionResult When calling a form action via fetch, the response will be one of these shapes. ```svelte

{ return ({ result }) => { // result is of type ActionResult }; }} ```

```dts type ActionResult< Success extends | Record | undefined = Record, Failure extends | Record | undefined = Record > = | { type: 'success'; status: number; data?: Success } | { type: 'failure'; status: number; data?: Failure } | { type: 'redirect'; status: number; location: string } | { type: 'error'; status?: number; error: any }; ```

## Actions Shape of the `export const actions = {...}` object in `+page.server.js`. See [form actions](/docs/kit/form-actions) for more information.

```dts type Actions< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, OutputData extends Record | void = Record< string, any > | void, RouteId extends AppRouteId | null = AppRouteId | null > = Record>; ```

## Adapter [Adapters](/docs/kit/adapters) are responsible for taking the production build and turning it into something that can be deployed to a platform of your choosing.

```dts interface Adapter {/*…*/} ```

```dts name: string; ```

The name of the adapter, using for logging. Will typically correspond to the package name.

```dts adapt: (builder: Builder) => MaybePromise; ```

- `builder` An object provided by SvelteKit that contains methods for adapting the app

This function is called after SvelteKit has built your app.

```dts supports?: {/*…*/} ```

Checks called during dev and build to determine whether specific features will work in production with this adapter.

```dts read?: (details: { config: any; route: { id: string } }) => boolean; ```

- `details.config` The merged route config

Test support for `read` from `$app/server`.

```dts instrumentation?: () => boolean; ```

- available since v2.31.0

Test support for `instrumentation.server.js`. To pass, the adapter must support running `instrumentation.server.js` prior to the application code.

```dts emulate?: () => MaybePromise; ```

Creates an `Emulator`, which allows the adapter to influence the environment during dev, build and prerendering.

## AfterNavigate The argument passed to [`afterNavigate`](/docs/kit/$app-navigation#afterNavigate) callbacks.

```dts type AfterNavigate = (Navigation | NavigationEnter) & { /** * The type of navigation: * - `enter`: The app has hydrated/started * - `form`: The user submitted a `` * - `link`: Navigation was triggered by a link click * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect * - `popstate`: Navigation was triggered by back/forward navigation */ type: Exclude; /** * Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page. */ willUnload: false; }; ```

## AwaitedActions

```dts type AwaitedActions< T extends Record any> > = OptionalUnion< { [Key in keyof T]: UnpackValidationError< Awaited> >; }[keyof T] >; ```

## BeforeNavigate The argument passed to [`beforeNavigate`](/docs/kit/$app-navigation#beforeNavigate) callbacks.

```dts type BeforeNavigate = Navigation & { /** * Call this to prevent the navigation from starting. */ cancel: () => void; }; ```

## Builder This object is passed to the `adapt` function of adapters. It contains various methods and properties that are useful for adapting the app.

```dts interface Builder {/*…*/} ```

```dts log: Logger; ```

Print messages to the console. `log.info` and `log.minor` are silent unless Vite's `logLevel` is `info`.

```dts rimraf: (dir: string) => void; ```

Remove `dir` and all its contents.

```dts mkdirp: (dir: string) => void; ```

Create `dir` and any required parent directories.

```dts config: ValidatedConfig; ```

The fully resolved Svelte config.

```dts prerendered: Prerendered; ```

Information about prerendered pages and assets, if any.

```dts routes: RouteDefinition[]; ```

An array of all routes (including prerendered)

```dts createEntries: (fn: (route: RouteDefinition) => AdapterEntry) => Promise; ```

- `fn` A function that groups a set of routes into an entry point - deprecated Use `builder.routes` instead

Create separate functions that map to one or more routes of your app.

```dts findServerAssets: (routes: RouteDefinition[]) => string[]; ```

Find all the assets imported by server files belonging to `routes`

```dts generateFallback: (dest: string) => Promise; ```

Generate a fallback page for a static webserver to use when no route is matched. Useful for single-page apps.

```dts generateEnvModule: () => void; ```

Generate a module exposing build-time environment variables as `$env/dynamic/public`.

```dts generateManifest: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string; ```

- `opts` a relative path to the base directory of the app and optionally in which format (esm or cjs) the manifest should be generated

Generate a server-side manifest to initialise the SvelteKit [server](/docs/kit/@sveltejs-kit#Server) with.

```dts getBuildDirectory: (name: string) => string; ```

- `name` path to the file, relative to the build directory

Resolve a path to the `name` directory inside `outDir`, e.g. `/path/to/.svelte-kit/my-adapter`.

```dts getClientDirectory: () => string; ```

Get the fully resolved path to the directory containing client-side assets, including the contents of your `static` directory.

```dts getServerDirectory: () => string; ```

Get the fully resolved path to the directory containing server-side code.

```dts getAppPath: () => string; ```

Get the application path including any configured `base` path, e.g. `my-base-path/_app`.

```dts writeClient: (dest: string) => string[]; ```

- `dest` the destination folder - returns an array of files written to `dest`

Write client assets to `dest`.

```dts writePrerendered: (dest: string) => string[]; ```

- `dest` the destination folder - returns an array of files written to `dest`

Write prerendered files to `dest`.

```dts writeServer: (dest: string) => string[]; ```

- `dest` the destination folder - returns an array of files written to `dest`

Write server-side code to `dest`.

```dts copy: ( from: string, to: string, opts?: { filter?(basename: string): boolean; replace?: Record; } ) => string[]; ```

- `from` the source file or directory - `to` the destination file or directory - `opts.filter` a function to determine whether a file or directory should be copied - `opts.replace` a map of strings to replace - returns an array of files that were copied

Copy a file or directory.

```dts hasServerInstrumentationFile: () => boolean; ```

- returns true if the server instrumentation file exists, false otherwise - available since v2.31.0

Check if the server instrumentation file exists.

```dts instrument: (args: { entrypoint: string; instrumentation: string; start?: string; module?: | { exports: string[]; } | { generateText: (args: { instrumentation: string; start: string }) => string; }; }) => void; ```

- `options` an object containing the following properties: - `options.entrypoint` the path to the entrypoint to trace. - `options.instrumentation` the path to the instrumentation file. - `options.start` the name of the start file. This is what `entrypoint` will be renamed to. - `options.module` configuration for the resulting entrypoint module. - `options.module.generateText` a function that receives the relative paths to the instrumentation and start files, and generates the text of the module to be traced. If not provided, the default implementation will be used, which uses top-level await. - available since v2.31.0

Instrument `entrypoint` with `instrumentation`. Renames `entrypoint` to `start` and creates a new module at `entrypoint` which imports `instrumentation` and then dynamically imports `start`. This allows the module hooks necessary for instrumentation libraries to be loaded prior to any application code. Caveats: - "Live exports" will not work. If your adapter uses live exports, your users will need to manually import the server instrumentation on startup. - If `tla` is `false`, OTEL auto-instrumentation may not work properly. Use it if your environment supports it. - Use `hasServerInstrumentationFile` to check if the user has a server instrumentation file; if they don't, you shouldn't do this.

```dts compress: (directory: string) => Promise; ```

- `directory` The directory containing the files to be compressed

Compress files in `directory` with gzip and brotli, where appropriate. Generates `.gz` and `.br` files alongside the originals.

## ClientInit

Available since 2.10.0

The [`init`](/docs/kit/hooks#Shared-hooks-init) will be invoked once the app starts in the browser

```dts type ClientInit = () => MaybePromise; ```

## Config See the [configuration reference](/docs/kit/configuration) for details. ## Cookies

```dts interface Cookies {/*…*/} ```

```dts get: (name: string, opts?: import('cookie').CookieParseOptions) => string | undefined; ```

- `name` the name of the cookie - `opts` the options, passed directly to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)

Gets a cookie that was previously set with `cookies.set`, or from the request headers.

```dts getAll: (opts?: import('cookie').CookieParseOptions) => Array<{ name: string; value: string }>; ```

- `opts` the options, passed directly to `cookie.parse`. See documentation [here](https://github.com/jshttp/cookie#cookieparsestr-options)

Gets all cookies that were previously set with `cookies.set`, or from the request headers.

```dts set: ( name: string, value: string, opts: import('cookie').CookieSerializeOptions & { path: string } ) => void; ```

- `name` the name of the cookie - `value` the cookie value - `opts` the options, passed directly to `cookie.serialize`. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)

Sets a cookie. This will add a `set-cookie` header to the response, but also make the cookie available via `cookies.get` or `cookies.getAll` during the current request. The `httpOnly` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`. You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children

```dts delete: (name: string, opts: import('cookie').CookieSerializeOptions & { path: string }) => void; ```

- `name` the name of the cookie - `opts` the options, passed directly to `cookie.serialize`. The `path` must match the path of the cookie you want to delete. See documentation [here](https://github.com/jshttp/cookie#cookieserializename-value-options)

Deletes a cookie by setting its value to an empty string and setting the expiry date in the past. You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children

```dts serialize: ( name: string, value: string, opts: import('cookie').CookieSerializeOptions & { path: string } ) => string; ```

Serialize a cookie name-value pair into a `Set-Cookie` header string, but don't apply it to the response. The `httpOnly` and `secure` options are `true` by default (except on http://localhost, where `secure` is `false`), and must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `sameSite` option defaults to `lax`. You must specify a `path` for the cookie. In most cases you should explicitly set `path: '/'` to make the cookie available throughout your app. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children

## Emulator A collection of functions that influence the environment during dev, build and prerendering

```dts interface Emulator {/*…*/} ```

```dts platform?(details: { config: any; prerender: PrerenderOption }): MaybePromise; ```

A function that is called with the current route `config` and `prerender` option and returns an `App.Platform` object

## Handle The [`handle`](/docs/kit/hooks#Server-hooks-handle) hook runs every time the SvelteKit server receives a [request](/docs/kit/web-standards#Fetch-APIs-Request) and determines the [response](/docs/kit/web-standards#Fetch-APIs-Response). It receives an `event` object representing the request and a function called `resolve`, which renders the route and generates a `Response`. This allows you to modify response headers or bodies, or bypass SvelteKit entirely (for implementing routes programmatically, for example).

```dts type Handle = (input: { event: RequestEvent; resolve: ( event: RequestEvent, opts?: ResolveOptions ) => MaybePromise; }) => MaybePromise; ```

## HandleClientError The client-side [`handleError`](/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while navigating. If an unexpected error is thrown during loading or the following render, this function will be called with the error and the event. Make sure that this function _never_ throws an error.

```dts type HandleClientError = (input: { error: unknown; event: NavigationEvent; status: number; message: string; }) => MaybePromise; ```

## HandleFetch The [`handleFetch`](/docs/kit/hooks#Server-hooks-handleFetch) hook allows you to modify (or replace) the result of an [`event.fetch`](/docs/kit/load#Making-fetch-requests) call that runs on the server (or during prerendering) inside an endpoint, `load`, `action`, `handle`, `handleError` or `reroute`.

```dts type HandleFetch = (input: { event: RequestEvent; request: Request; fetch: typeof fetch; }) => MaybePromise; ```

## HandleServerError The server-side [`handleError`](/docs/kit/hooks#Shared-hooks-handleError) hook runs when an unexpected error is thrown while responding to a request. If an unexpected error is thrown during loading or rendering, this function will be called with the error and the event. Make sure that this function _never_ throws an error.

```dts type HandleServerError = (input: { error: unknown; event: RequestEvent; status: number; message: string; }) => MaybePromise; ```

## HandleValidationError The [`handleValidationError`](/docs/kit/hooks#Server-hooks-handleValidationError) hook runs when the argument to a remote function fails validation. It will be called with the validation issues and the event, and must return an object shape that matches `App.Error`.

```dts type HandleValidationError< Issue extends StandardSchemaV1.Issue = StandardSchemaV1.Issue > = (input: { issues: Issue[]; event: RequestEvent; }) => MaybePromise; ```

## HttpError The object returned by the [`error`](/docs/kit/@sveltejs-kit#error) function.

```dts interface HttpError {/*…*/} ```

```dts status: number; ```

The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses), in the range 400-599.

```dts body: App.Error; ```

The content of the error.

## Invalid A function and proxy object used to imperatively create validation errors in form handlers. Call `invalid(issue1, issue2, ...issueN)` to throw a validation error. If an issue is a `string`, it applies to the form as a whole (and will show up in `fields.allIssues()`) Access properties to create field-specific issues: `invalid.fieldName('message')`. The type structure mirrors the input data structure for type-safe field access.

```dts type Invalid = (( ...issues: Array ) => never) & InvalidField; ```

## KitConfig See the [configuration reference](/docs/kit/configuration) for details. ## LessThan

```dts type LessThan< TNumber extends number, TArray extends any[] = [] > = TNumber extends TArray['length'] ? TArray[number] : LessThan; ```

## Load The generic form of `PageLoad` and `LayoutLoad`. You should import those from `./$types` (see [generated types](/docs/kit/types#Generated-types)) rather than using `Load` directly.

```dts type Load< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, InputData extends Record | null = Record< string, any > | null, ParentData extends Record = Record< string, any >, OutputData extends Record< string, unknown > | void = Record | void, RouteId extends AppRouteId | null = AppRouteId | null > = ( event: LoadEvent ) => MaybePromise; ```

## LoadEvent The generic form of `PageLoadEvent` and `LayoutLoadEvent`. You should import those from `./$types` (see [generated types](/docs/kit/types#Generated-types)) rather than using `LoadEvent` directly.

```dts interface LoadEvent< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, Data extends Record | null = Record< string, any > | null, ParentData extends Record = Record< string, any >, RouteId extends AppRouteId | null = AppRouteId | null > extends NavigationEvent {/*…*/} ```

```dts fetch: typeof fetch; ```

`fetch` is equivalent to the [native `fetch` web API](https://developer.mozilla.org/en-US/docs/Web/API/fetch), with a few additional features: - It can be used to make credentialed requests on the server, as it inherits the `cookie` and `authorization` headers for the page request. - It can make relative requests on the server (ordinarily, `fetch` requires a URL with an origin when used in a server context). - Internal requests (e.g. for `+server.js` routes) go directly to the handler function when running on the server, without the overhead of an HTTP call. - During server-side rendering, the response will be captured and inlined into the rendered HTML by hooking into the `text` and `json` methods of the `Response` object. Note that headers will _not_ be serialized, unless explicitly included via [`filterSerializedResponseHeaders`](/docs/kit/hooks#Server-hooks-handle) - During hydration, the response will be read from the HTML, guaranteeing consistency and preventing an additional network request. You can learn more about making credentialed requests with cookies [here](/docs/kit/load#Cookies)

```dts data: Data; ```

Contains the data returned by the route's server `load` function (in `+layout.server.js` or `+page.server.js`), if any.

```dts setHeaders: (headers: Record) => void; ```

If you need to set headers for the response, you can do so using the this method. This is useful if you want the page to be cached, for example: ```js // @errors: 7031 /// file: src/routes/blog/+page.js export async function load({ fetch, setHeaders }) { const url = `https://cms.example.com/articles.json`; const response = await fetch(url); setHeaders({ age: response.headers.get('age'), 'cache-control': response.headers.get('cache-control') }); return response.json(); } ``` Setting the same header multiple times (even in separate `load` functions) is an error — you can only set a given header once. You cannot add a `set-cookie` header with `setHeaders` — use the [`cookies`](/docs/kit/@sveltejs-kit#Cookies) API in a server-only `load` function instead. `setHeaders` has no effect when a `load` function runs in the browser.

```dts parent: () => Promise; ```

`await parent()` returns data from parent `+layout.js` `load` functions. Implicitly, a missing `+layout.js` is treated as a `({ data }) => data` function, meaning that it will return and forward data from parent `+layout.server.js` files. Be careful not to introduce accidental waterfalls when using `await parent()`. If for example you only want to merge parent data into the returned output, call it _after_ fetching your other data.

```dts depends: (...deps: Array<`${string}:${string}`>) => void; ```

This function declares that the `load` function has a _dependency_ on one or more URLs or custom identifiers, which can subsequently be used with [`invalidate()`](/docs/kit/$app-navigation#invalidate) to cause `load` to rerun. Most of the time you won't need this, as `fetch` calls `depends` on your behalf — it's only necessary if you're using a custom API client that bypasses `fetch`. URLs can be absolute or relative to the page being loaded, and must be [encoded](https://developer.mozilla.org/en-US/docs/Glossary/percent-encoding). Custom identifiers have to be prefixed with one or more lowercase letters followed by a colon to conform to the [URI specification](https://www.rfc-editor.org/rfc/rfc3986.html). The following example shows how to use `depends` to register a dependency on a custom identifier, which is `invalidate`d after a button click, making the `load` function rerun. ```js // @errors: 7031 /// file: src/routes/+page.js let count = 0; export async function load({ depends }) { depends('increase:count'); return { count: count++ }; } ``` ```html /// file: src/routes/+page.svelte

{data.count}

```

```dts untrack: (fn: () => T) => T; ```

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example: ```js // @errors: 7031 /// file: src/routes/+page.server.js export async function load({ untrack, url }) { // Untrack url.pathname so that path changes don't trigger a rerun if (untrack(() => url.pathname === '/')) { return { message: 'Welcome!' }; } } ```

```dts tracing: {/*…*/} ```

- available since v2.31.0

Access to spans for tracing. If tracing is not enabled or the function is being run in the browser, these spans will do nothing.

```dts enabled: boolean; ```

Whether tracing is enabled.

```dts root: Span; ```

The root span for the request. This span is named `sveltekit.handle.root`.

```dts current: Span; ```

The span associated with the current `load` function.

## LoadProperties

```dts type LoadProperties< input extends Record | void > = input extends void ? undefined // needs to be undefined, because void will break intellisense : input extends Record ? input : unknown; ```

## Navigation

```dts type Navigation = | NavigationExternal | NavigationFormSubmit | NavigationPopState | NavigationLink; ```

## NavigationBase

```dts interface NavigationBase {/*…*/} ```

```dts from: NavigationTarget | null; ```

Where navigation was triggered from

```dts to: NavigationTarget | null; ```

Where navigation is going to/has gone to

```dts willUnload: boolean; ```

Whether or not the navigation will result in the page being unloaded (i.e. not a client-side navigation)

```dts complete: Promise; ```

A promise that resolves once the navigation is complete, and rejects if the navigation fails or is aborted. In the case of a `willUnload` navigation, the promise will never resolve

## NavigationEnter

```dts interface NavigationEnter extends NavigationBase {/*…*/} ```

```dts type: 'enter'; ```

The type of navigation: - `form`: The user submitted a `` - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring - `link`: Navigation was triggered by a link click - `goto`: Navigation was triggered by a `goto(...)` call or a redirect - `popstate`: Navigation was triggered by back/forward navigation

```dts delta?: undefined; ```

In case of a history back/forward navigation, the number of steps to go back/forward

```dts event?: undefined; ```

Dispatched `Event` object when navigation occured by `popstate` or `link`.

## NavigationEvent

```dts interface NavigationEvent< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```

```dts params: Params; ```

The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object

```dts route: {/*…*/} ```

Info about the current route

```dts id: RouteId; ```

The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.

```dts url: URL; ```

The URL of the current page

## NavigationExternal

```dts interface NavigationExternal extends NavigationBase {/*…*/} ```

```dts type: Exclude; ```

```dts delta?: undefined; ```

In case of a history back/forward navigation, the number of steps to go back/forward

## NavigationFormSubmit

```dts interface NavigationFormSubmit extends NavigationBase {/*…*/} ```

```dts type: 'form'; ```

```dts event: SubmitEvent; ```

The `SubmitEvent` that caused the navigation

```dts delta?: undefined; ```

In case of a history back/forward navigation, the number of steps to go back/forward

## NavigationLink

```dts interface NavigationLink extends NavigationBase {/*…*/} ```

```dts type: 'link'; ```

```dts event: PointerEvent; ```

The `PointerEvent` that caused the navigation

```dts delta?: undefined; ```

In case of a history back/forward navigation, the number of steps to go back/forward

## NavigationPopState

```dts interface NavigationPopState extends NavigationBase {/*…*/} ```

```dts type: 'popstate'; ```

```dts delta: number; ```

In case of a history back/forward navigation, the number of steps to go back/forward

```dts event: PopStateEvent; ```

The `PopStateEvent` that caused the navigation

## NavigationTarget Information about the target of a specific navigation.

```dts interface NavigationTarget< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```

```dts params: Params | null; ```

Parameters of the target page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object. Is `null` if the target is not part of the SvelteKit app (could not be resolved to a route).

```dts route: {/*…*/} ```

Info about the target route

```dts id: RouteId | null; ```

The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.

```dts url: URL; ```

The URL that is navigated to

## NavigationType - `enter`: The app has hydrated/started - `form`: The user submitted a `` - `leave`: The app is being left either because the tab is being closed or a navigation to a different document is occurring - `link`: Navigation was triggered by a link click - `goto`: Navigation was triggered by a `goto(...)` call or a redirect - `popstate`: Navigation was triggered by back/forward navigation

## NumericRange

```dts type NumericRange< TStart extends number, TEnd extends number > = Exclude, LessThan>; ```

## OnNavigate The argument passed to [`onNavigate`](/docs/kit/$app-navigation#onNavigate) callbacks.

```dts type OnNavigate = Navigation & { /** * The type of navigation: * - `form`: The user submitted a `` * - `link`: Navigation was triggered by a link click * - `goto`: Navigation was triggered by a `goto(...)` call or a redirect * - `popstate`: Navigation was triggered by back/forward navigation */ type: Exclude; /** * Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page. */ willUnload: false; }; ```

## Page The shape of the [`page`](/docs/kit/$app-state#page) reactive object and the [`$page`](/docs/kit/$app-stores) store.

```dts interface Page< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```

```dts url: URL & { pathname: ResolvedPathname }; ```

The URL of the current page.

```dts params: Params; ```

The parameters of the current page - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.

```dts route: {/*…*/} ```

Info about the current route.

```dts id: RouteId; ```

The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.

```dts status: number; ```

HTTP status code of the current page.

```dts error: App.Error | null; ```

The error object of the current page, if any. Filled from the `handleError` hooks.

```dts data: App.PageData & Record; ```

The merged result of all data from all `load` functions on the current page. You can type a common denominator through `App.PageData`.

```dts state: App.PageState; ```

The page state, which can be manipulated using the [`pushState`](/docs/kit/$app-navigation#pushState) and [`replaceState`](/docs/kit/$app-navigation#replaceState) functions from `$app/navigation`.

```dts form: any; ```

Filled only after a form submission. See [form actions](/docs/kit/form-actions) for more info.

## ParamMatcher The shape of a param matcher. See [matching](/docs/kit/advanced-routing#Matching) for more info.

```dts type ParamMatcher = (param: string) => boolean; ```

## PrerenderOption

```dts type PrerenderOption = boolean | 'auto'; ```

## Redirect The object returned by the [`redirect`](/docs/kit/@sveltejs-kit#redirect) function.

```dts interface Redirect {/*…*/} ```

```dts status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308; ```

The [HTTP status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#redirection_messages), in the range 300-308.

```dts location: string; ```

The location to redirect to.

## RemoteCommand The return value of a remote `command` function. See [Remote functions](/docs/kit/remote-functions#command) for full documentation.

```dts type RemoteCommand = { (arg: Input): Promise> & { updates( ...queries: Array< RemoteQuery | RemoteQueryOverride > ): Promise>; }; /** The number of pending command executions */ get pending(): number; }; ```

## RemoteForm The return value of a remote `form` function. See [Remote functions](/docs/kit/remote-functions#form) for full documentation.

```dts type RemoteForm< Input extends RemoteFormInput | void, Output > = { /** Attachment that sets up an event handler that intercepts the form submission on the client to prevent a full page reload */ [attachment: symbol]: (node: HTMLFormElement) => void; method: 'POST'; /** The URL to send the form to. */ action: string; /** Use the `enhance` method to influence what happens when the form is submitted. */ enhance( callback: (opts: { form: HTMLFormElement; data: Input; submit: () => Promise & { updates: ( ...queries: Array< RemoteQuery | RemoteQueryOverride > ) => Promise; }; }) => void | Promise ): { method: 'POST'; action: string; [attachment: symbol]: (node: HTMLFormElement) => void; }; /** * Create an instance of the form for the given `id`. * The `id` is stringified and used for deduplication to potentially reuse existing instances. * Useful when you have multiple forms that use the same remote form action, for example in a loop. * ```svelte * {#each todos as todo} * {@const todoForm = updateTodo.for(todo.id)} * * {#if todoForm.result?.invalid}

Invalid data

{/if} * ... * * {/each} * ``` */ for( id: ExtractId ): Omit, 'for'>; /** Preflight checks */ preflight( schema: StandardSchemaV1 ): RemoteForm; /** Validate the form contents programmatically */ validate(options?: { /** Set this to `true` to also show validation issues of fields that haven't been touched yet. */ includeUntouched?: boolean; /** Set this to `true` to only run the `preflight` validation. */ preflightOnly?: boolean; /** Perform validation as if the form was submitted by the given button. */ submitter?: HTMLButtonElement | HTMLInputElement; }): Promise; /** The result of the form submission */ get result(): Output | undefined; /** The number of pending submissions */ get pending(): number; /** Access form fields using object notation */ fields: Input extends void ? never : RemoteFormFields; /** Spread this onto a `

## RemoteFormField Form field accessor type that provides name(), value(), and issues() methods

```dts type RemoteFormField = RemoteFormFieldMethods & { /** * Returns an object that can be spread onto an input element with the correct type attribute, * aria-invalid attribute if the field is invalid, and appropriate value/checked property getters/setters. * @example * ```svelte * * * * ``` */ as>( ...args: AsArgs ): InputElementProps; }; ```

## RemoteFormFieldType

```dts type RemoteFormFieldType = { [K in keyof InputTypeMap]: T extends InputTypeMap[K] ? K : never; }[keyof InputTypeMap]; ```

## RemoteFormFieldValue

## RemoteFormFields Recursive type to build form fields structure with proxy access

```dts type RemoteFormFields = WillRecurseIndefinitely extends true ? RecursiveFormFields : NonNullable extends | string | number | boolean | File ? RemoteFormField> : T extends string[] | File[] ? RemoteFormField & { [K in number]: RemoteFormField; } : T extends Array ? RemoteFormFieldContainer & { [K in number]: RemoteFormFields; } : RemoteFormFieldContainer & { [K in keyof T]-?: RemoteFormFields; }; ```

## RemoteFormInput

```dts interface RemoteFormInput {/*…*/} ```

```dts [key: string]: MaybeArray; ```

## RemoteFormIssue

```dts interface RemoteFormIssue {/*…*/} ```

```dts message: string; ```

```dts path: Array; ```

## RemotePrerenderFunction The return value of a remote `prerender` function. See [Remote functions](/docs/kit/remote-functions#prerender) for full documentation.

```dts type RemotePrerenderFunction = ( arg: Input ) => RemoteResource; ```

## RemoteQuery

```dts type RemoteQuery = RemoteResource & { /** * On the client, this function will update the value of the query without re-fetching it. * * On the server, this can be called in the context of a `command` or `form` and the specified data will accompany the action response back to the client. * This prevents SvelteKit needing to refresh all queries on the page in a second server round-trip. */ set(value: T): void; /** * On the client, this function will re-fetch the query from the server. * * On the server, this can be called in the context of a `command` or `form` and the refreshed data will accompany the action response back to the client. * This prevents SvelteKit needing to refresh all queries on the page in a second server round-trip. */ refresh(): Promise; /** * Temporarily override the value of a query. This is used with the `updates` method of a [command](https://svelte.dev/docs/kit/remote-functions#command-Updating-queries) or [enhanced form submission](https://svelte.dev/docs/kit/remote-functions#form-enhance) to provide optimistic updates. * * ```svelte * * * * ``` */ withOverride( update: (current: Awaited) => Awaited ): RemoteQueryOverride; }; ```

## RemoteQueryFunction The return value of a remote `query` function. See [Remote functions](/docs/kit/remote-functions#query) for full documentation.

```dts type RemoteQueryFunction = ( arg: Input ) => RemoteQuery; ```

## RemoteQueryOverride

```dts interface RemoteQueryOverride {/*…*/} ```

```dts _key: string; ```

```dts release(): void; ```

## RemoteResource

```dts type RemoteResource = Promise> & { /** The error in case the query fails. Most often this is a [`HttpError`](https://svelte.dev/docs/kit/@sveltejs-kit#HttpError) but it isn't guaranteed to be. */ get error(): any; /** `true` before the first result is available and during refreshes */ get loading(): boolean; } & ( | { /** The current value of the query. Undefined until `ready` is `true` */ get current(): undefined; ready: false; } | { /** The current value of the query. Undefined until `ready` is `true` */ get current(): Awaited; ready: true; } ); ```

## RequestEvent

```dts interface RequestEvent< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```

```dts cookies: Cookies; ```

Get or set cookies related to the current request

```dts fetch: typeof fetch; ```

```dts getClientAddress: () => string; ```

The client's IP address, set by the adapter.

```dts locals: App.Locals; ```

Contains custom data that was added to the request within the [`server handle hook`](/docs/kit/hooks#Server-hooks-handle).

```dts params: Params; ```

The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object.

```dts platform: Readonly | undefined; ```

Additional data made available through the adapter.

```dts request: Request; ```

The original request object.

```dts route: {/*…*/} ```

Info about the current route.

```dts id: RouteId; ```

The ID of the current route - e.g. for `src/routes/blog/[slug]`, it would be `/blog/[slug]`. It is `null` when no route is matched.

```dts setHeaders: (headers: Record) => void; ```

```dts url: URL; ```

The requested URL.

```dts isDataRequest: boolean; ```

`true` if the request comes from the client asking for `+page/layout.server.js` data. The `url` property will be stripped of the internal information related to the data request in this case. Use this property instead if the distinction is important to you.

```dts isSubRequest: boolean; ```

`true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.

```dts tracing: {/*…*/} ```

- available since v2.31.0

Access to spans for tracing. If tracing is not enabled, these spans will do nothing.

```dts enabled: boolean; ```

Whether tracing is enabled.

```dts root: Span; ```

The root span for the request. This span is named `sveltekit.handle.root`.

```dts current: Span; ```

The span associated with the current `handle` hook, `load` function, or form action.

```dts isRemoteRequest: boolean; ```

`true` if the request comes from the client via a remote function. The `url` property will be stripped of the internal information related to the data request in this case. Use this property instead if the distinction is important to you.

## RequestHandler A `(event: RequestEvent) => Response` function exported from a `+server.js` file that corresponds to an HTTP verb (`GET`, `PUT`, `PATCH`, etc) and handles requests with that method. It receives `Params` as the first generic argument, which you can skip by using [generated types](/docs/kit/types#Generated-types) instead.

```dts type RequestHandler< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > = ( event: RequestEvent ) => MaybePromise; ```

## Reroute

Available since 2.3.0

The [`reroute`](/docs/kit/hooks#Universal-hooks-reroute) hook allows you to modify the URL before it is used to determine which route to render.

```dts type Reroute = (event: { url: URL; fetch: typeof fetch; }) => MaybePromise; ```

## ResolveOptions

```dts interface ResolveOptions {/*…*/} ```

```dts transformPageChunk?: (input: { html: string; done: boolean }) => MaybePromise; ```

- `input` the html chunk and the info if this is the last chunk

Applies custom transforms to HTML. If `done` is true, it's the final chunk. Chunks are not guaranteed to be well-formed HTML (they could include an element's opening tag but not its closing tag, for example) but they will always be split at sensible boundaries such as `%sveltekit.head%` or layout/page components.

```dts filterSerializedResponseHeaders?: (name: string, value: string) => boolean; ```

- `name` header name - `value` header value

Determines which headers should be included in serialized responses when a `load` function loads a resource with `fetch`. By default, none will be included.

```dts preload?: (input: { type: 'font' | 'css' | 'js' | 'asset'; path: string }) => boolean; ```

- `input` the type of the file and its path

Determines what should be added to the `` tag to preload it. By default, `js` and `css` files will be preloaded.

## RouteDefinition

```dts interface RouteDefinition {/*…*/} ```

```dts id: string; ```

```dts api: { methods: Array; }; ```

```dts page: { methods: Array>; }; ```

```dts pattern: RegExp; ```

```dts prerender: PrerenderOption; ```

```dts segments: RouteSegment[]; ```

```dts methods: Array; ```

```dts config: Config; ```

## SSRManifest

```dts interface SSRManifest {/*…*/} ```

```dts appDir: string; ```

```dts appPath: string; ```

```dts assets: Set; ```

Static files from `kit.config.files.assets` and the service worker (if any).

```dts mimeTypes: Record; ```

```dts _: {/*…*/} ```

private fields

```dts client: NonNullable; ```

```dts nodes: SSRNodeLoader[]; ```

```dts remotes: Record Promise>; ```

hashed filename -> import to that file

```dts routes: SSRRoute[]; ```

```dts prerendered_routes: Set; ```

```dts matchers: () => Promise>; ```

```dts server_assets: Record; ```

A `[file]: size` map of all assets imported by server code.

## ServerInit

Available since 2.10.0

The [`init`](/docs/kit/hooks#Shared-hooks-init) will be invoked before the server responds to its first request

```dts type ServerInit = () => MaybePromise; ```

## ServerInitOptions

```dts interface ServerInitOptions {/*…*/} ```

```dts env: Record; ```

A map of environment variables.

```dts read?: (file: string) => MaybePromise; ```

A function that turns an asset filename into a `ReadableStream`. Required for the `read` export from `$app/server` to work.

## ServerLoad The generic form of `PageServerLoad` and `LayoutServerLoad`. You should import those from `./$types` (see [generated types](/docs/kit/types#Generated-types)) rather than using `ServerLoad` directly.

```dts type ServerLoad< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, ParentData extends Record = Record< string, any >, OutputData extends Record | void = Record< string, any > | void, RouteId extends AppRouteId | null = AppRouteId | null > = ( event: ServerLoadEvent ) => MaybePromise; ```

## ServerLoadEvent

```dts interface ServerLoadEvent< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, ParentData extends Record = Record< string, any >, RouteId extends AppRouteId | null = AppRouteId | null > extends RequestEvent {/*…*/} ```

```dts parent: () => Promise; ```

`await parent()` returns data from parent `+layout.server.js` `load` functions. Be careful not to introduce accidental waterfalls when using `await parent()`. If for example you only want to merge parent data into the returned output, call it _after_ fetching your other data.

```dts depends: (...deps: string[]) => void; ```

{data.count}

```

```dts untrack: (fn: () => T) => T; ```

Use this function to opt out of dependency tracking for everything that is synchronously called within the callback. Example: ```js // @errors: 7031 /// file: src/routes/+page.js export async function load({ untrack, url }) { // Untrack url.pathname so that path changes don't trigger a rerun if (untrack(() => url.pathname === '/')) { return { message: 'Welcome!' }; } } ```

```dts tracing: {/*…*/} ```

- available since v2.31.0

Access to spans for tracing. If tracing is not enabled, these spans will do nothing.

```dts enabled: boolean; ```

Whether tracing is enabled.

```dts root: Span; ```

The root span for the request. This span is named `sveltekit.handle.root`.

```dts current: Span; ```

The span associated with the current server `load` function.

## Snapshot The type of `export const snapshot` exported from a page or layout component.

```dts interface Snapshot {/*…*/} ```

```dts capture: () => T; ```

```dts restore: (snapshot: T) => void; ```

## SubmitFunction

```dts type SubmitFunction< Success extends | Record | undefined = Record, Failure extends | Record | undefined = Record > = (input: { action: URL; formData: FormData; formElement: HTMLFormElement; controller: AbortController; submitter: HTMLElement | null; cancel: () => void; }) => MaybePromise< | void | ((opts: { formData: FormData; formElement: HTMLFormElement; action: URL; result: ActionResult; /** * Call this to get the default behavior of a form submission response. * @param options Set `reset: false` if you don't want the `

## Transport

Available since 2.11.0

The [`transport`](/docs/kit/hooks#Universal-hooks-transport) hook allows you to transport custom types across the server/client boundary. Each transporter has a pair of `encode` and `decode` functions. On the server, `encode` determines whether a value is an instance of the custom type and, if so, returns a non-falsy encoding of the value which can be an object or an array (or `false` otherwise). In the browser, `decode` turns the encoding back into an instance of the custom type. ```ts import type { Transport } from '@sveltejs/kit'; declare class MyCustomType { data: any } // hooks.js export const transport: Transport = { MyCustomType: { encode: (value) => value instanceof MyCustomType && [value.data], decode: ([data]) => new MyCustomType(data) } }; ```

```dts type Transport = Record; ```

## Transporter A member of the [`transport`](/docs/kit/hooks#Universal-hooks-transport) hook.

```dts interface Transporter< T = any, U = Exclude< any, false | 0 | '' | null | undefined | typeof NaN > > {/*…*/} ```

```dts encode: (value: T) => false | U; ```

```dts decode: (data: U) => T; ```

## Private types The following are referenced by the public types documented above, but cannot be imported directly: ## AdapterEntry

```dts interface AdapterEntry {/*…*/} ```

```dts id: string; ```

A string that uniquely identifies an HTTP service (e.g. serverless function) and is used for deduplication. For example, `/foo/a-[b]` and `/foo/[c]` are different routes, but would both be represented in a Netlify _redirects file as `/foo/:param`, so they share an ID

```dts filter(route: RouteDefinition): boolean; ```

A function that compares the candidate route with the current route to determine if it should be grouped with the current route. Use cases: - Fallback pages: `/foo/[c]` is a fallback for `/foo/a-[b]`, and `/[...catchall]` is a fallback for all routes - Grouping routes that share a common `config`: `/foo` should be deployed to the edge, `/bar` and `/baz` should be deployed to a serverless function

```dts complete(entry: { generateManifest(opts: { relativePath: string }): string }): MaybePromise; ```

A function that is invoked once the entry has been created. This is where you should write the function to the filesystem and generate redirect manifests.

## Csp

```dts namespace Csp { type ActionSource = 'strict-dynamic' | 'report-sample'; type BaseSource = | 'self' | 'unsafe-eval' | 'unsafe-hashes' | 'unsafe-inline' | 'wasm-unsafe-eval' | 'none'; type CryptoSource = `${'nonce' | 'sha256' | 'sha384' | 'sha512'}-${string}`; type FrameSource = | HostSource | SchemeSource | 'self' | 'none'; type HostNameScheme = `${string}.${string}` | 'localhost'; type HostSource = `${HostProtocolSchemes}${HostNameScheme}${PortScheme}`; type HostProtocolSchemes = `${string}://` | ''; type HttpDelineator = '/' | '?' | '#' | '\\'; type PortScheme = `:${number}` | '' | ':*'; type SchemeSource = | 'http:' | 'https:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:'; type Source = | HostSource | SchemeSource | CryptoSource | BaseSource; type Sources = Source[]; } ```

## CspDirectives

```dts interface CspDirectives {/*…*/} ```

```dts 'child-src'?: Csp.Sources; ```

```dts 'default-src'?: Array; ```

```dts 'frame-src'?: Csp.Sources; ```

```dts 'worker-src'?: Csp.Sources; ```

```dts 'connect-src'?: Csp.Sources; ```

```dts 'font-src'?: Csp.Sources; ```

```dts 'img-src'?: Csp.Sources; ```

```dts 'manifest-src'?: Csp.Sources; ```

```dts 'media-src'?: Csp.Sources; ```

```dts 'object-src'?: Csp.Sources; ```

```dts 'prefetch-src'?: Csp.Sources; ```

```dts 'script-src'?: Array; ```

```dts 'script-src-elem'?: Csp.Sources; ```

```dts 'script-src-attr'?: Csp.Sources; ```

```dts 'style-src'?: Array; ```

```dts 'style-src-elem'?: Csp.Sources; ```

```dts 'style-src-attr'?: Csp.Sources; ```

```dts 'base-uri'?: Array; ```

```dts 'form-action'?: Array; ```

```dts 'frame-ancestors'?: Array; ```

```dts 'navigate-to'?: Array; ```

```dts 'report-uri'?: string[]; ```

```dts 'report-to'?: string[]; ```

```dts 'require-trusted-types-for'?: Array<'script'>; ```

```dts 'trusted-types'?: Array<'none' | 'allow-duplicates' | '*' | string>; ```

```dts 'upgrade-insecure-requests'?: boolean; ```

```dts 'require-sri-for'?: Array<'script' | 'style' | 'script style'>; ```

- deprecated

```dts 'block-all-mixed-content'?: boolean; ```

- deprecated

```dts 'plugin-types'?: Array<`${string}/${string}` | 'none'>; ```

- deprecated

- deprecated

## HttpMethod

## Logger

```dts interface Logger {/*…*/} ```

```dts (msg: string): void; ```

```dts success(msg: string): void; ```

```dts error(msg: string): void; ```

```dts warn(msg: string): void; ```

```dts minor(msg: string): void; ```

```dts info(msg: string): void; ```

## MaybePromise

```dts type MaybePromise = T | Promise; ```

## PrerenderEntryGeneratorMismatchHandler

```dts interface PrerenderEntryGeneratorMismatchHandler {/*…*/} ```

```dts (details: { generatedFromId: string; entry: string; matchedId: string; message: string }): void; ```

## PrerenderEntryGeneratorMismatchHandlerValue

```dts type PrerenderEntryGeneratorMismatchHandlerValue = | 'fail' | 'warn' | 'ignore' | PrerenderEntryGeneratorMismatchHandler; ```

## PrerenderHttpErrorHandler

```dts interface PrerenderHttpErrorHandler {/*…*/} ```

```dts (details: { status: number; path: string; referrer: string | null; referenceType: 'linked' | 'fetched'; message: string; }): void; ```

## PrerenderHttpErrorHandlerValue

```dts type PrerenderHttpErrorHandlerValue = | 'fail' | 'warn' | 'ignore' | PrerenderHttpErrorHandler; ```

## PrerenderMap

```dts type PrerenderMap = Map; ```

## PrerenderMissingIdHandler

```dts interface PrerenderMissingIdHandler {/*…*/} ```

```dts (details: { path: string; id: string; referrers: string[]; message: string }): void; ```

## PrerenderMissingIdHandlerValue

```dts type PrerenderMissingIdHandlerValue = | 'fail' | 'warn' | 'ignore' | PrerenderMissingIdHandler; ```

## PrerenderOption

```dts type PrerenderOption = boolean | 'auto'; ```

## PrerenderUnseenRoutesHandler

```dts interface PrerenderUnseenRoutesHandler {/*…*/} ```

```dts (details: { routes: string[]; message: string }): void; ```

## PrerenderUnseenRoutesHandlerValue

```dts type PrerenderUnseenRoutesHandlerValue = | 'fail' | 'warn' | 'ignore' | PrerenderUnseenRoutesHandler; ```

## Prerendered

```dts interface Prerendered {/*…*/} ```

```dts pages: Map< string, { /** The location of the .html file relative to the output directory */ file: string; } >; ```

A map of `path` to `{ file }` objects, where a path like `/foo` corresponds to `foo.html` and a path like `/bar/` corresponds to `bar/index.html`.

```dts assets: Map< string, { /** The MIME type of the asset */ type: string; } >; ```

A map of `path` to `{ type }` objects.

```dts redirects: Map< string, { status: number; location: string; } >; ```

A map of redirects encountered during prerendering.

```dts paths: string[]; ```

An array of prerendered paths (without trailing slashes, regardless of the trailingSlash config)

## RequestOptions

```dts interface RequestOptions {/*…*/} ```

```dts getClientAddress(): string; ```

```dts platform?: App.Platform; ```

## RouteSegment

```dts interface RouteSegment {/*…*/} ```

```dts content: string; ```

```dts dynamic: boolean; ```

```dts rest: boolean; ```

## TrailingSlash

```dts type TrailingSlash = 'never' | 'always' | 'ignore'; ```

@sveltejs/kit API Reference