```js // @noErrors import { Server, VERSION, error, fail, isActionFailure, isHttpError, isRedirect, json, 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.

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

```dts function fail< T extends Record | undefined = undefined >(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 | undefined ): 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 | undefined ): Response; ```

## 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.

```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 | undefined ): 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 Partial> = Partial< Record >, OutputData extends Record | void = Record< string, any > | void, RouteId extends string | null = string | null > = ( event: RequestEvent ) => MaybePromise; ```

## ActionFailure

```dts interface ActionFailure< T extends Record | undefined = undefined > {/*…*/} ```

```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 Partial> = Partial< Record >, OutputData extends Record | void = Record< string, any > | void, RouteId extends string | null = string | 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; ```

- `config` The merged route config

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

```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 interface AfterNavigate extends Omit {/*…*/} ```

```dts type: Exclude; ```

The type of navigation: - `enter`: The app has hydrated - `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

```dts willUnload: false; ```

Since `afterNavigate` callbacks are called after a navigation completes, they will never be called with a navigation that unloads the page.

## 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 interface BeforeNavigate extends Navigation {/*…*/} ```

```dts cancel(): void; ```

Call this to prevent the navigation from starting.

## 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.js`.

```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](https://svelte.dev/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 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) a `fetch` request that happens inside a `load` function that runs on the server (or during pre-rendering)

```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; ```

## 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.

## 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 Partial> = Partial< Record >, InputData extends Record | null = Record< string, any > | null, ParentData extends Record = Record< string, any >, OutputData extends Record< string, unknown > | void = Record | void, RouteId extends string | null = string | 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 Partial> = Partial< Record >, Data extends Record | null = Record< string, any > | null, ParentData extends Record = Record< string, any >, RouteId extends string | null = string | 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`](https://svelte.dev/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](https://svelte.dev/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`](https://svelte.dev/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()`](https://svelte.dev/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!' }; } } ```

## 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 interface Navigation {/*…*/} ```

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

Where navigation was triggered from

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

Where navigation is going to/has gone to

```dts type: Exclude; ```

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 willUnload: boolean; ```

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

```dts delta?: number; ```

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

```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

## NavigationEvent

```dts interface NavigationEvent< Params extends Partial> = Partial< Record >, RouteId extends string | null = string | 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]`

```dts url: URL; ```

The URL of the current page

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

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

```dts params: Record | 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: { id: string | null }; ```

Info about the target route

```dts url: URL; ```

The URL that is navigated to

## NavigationType - `enter`: The app has hydrated - `form`: The user submitted a `` with a GET method - `leave`: The user is leaving the app by closing the tab or using the back/forward buttons to go to a different document - `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 interface OnNavigate extends Navigation {/*…*/} ```

```dts type: Exclude; ```

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

```dts willUnload: false; ```

Since `onNavigate` callbacks are called immediately before a client-side navigation, they will never be called with a navigation that unloads the page.

## Page The shape of the `$page` store

```dts interface Page< Params extends Record = Record< string, string >, RouteId extends string | null = string | null > {/*…*/} ```

```dts url: URL; ```

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]`

```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`](https://svelte.dev/docs/kit/$app-navigation#pushState) and [`replaceState`](https://svelte.dev/docs/kit/$app-navigation#replaceState) functions from `$app/navigation`.

```dts form: any; ```

Filled only after a form submission. See [form actions](https://svelte.dev/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.

## RequestEvent

```dts interface RequestEvent< Params extends Partial> = Partial< Record >, RouteId extends string | null = string | 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`](https://svelte.dev/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]`

```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.

## 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 Partial> = Partial< Record >, RouteId extends string | null = string | 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 }) => void | string; ```

## 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; ```

```dts mimeTypes: Record; ```

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

private fields

```dts client: NonNullable; ```

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

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

```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) => ReadableStream; ```

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 Partial> = Partial< Record >, ParentData extends Record = Record< string, any >, OutputData extends Record | void = Record< string, any > | void, RouteId extends string | null = string | null > = ( event: ServerLoadEvent ) => MaybePromise; ```

## ServerLoadEvent

```dts interface ServerLoadEvent< Params extends Partial> = Partial< Record >, ParentData extends Record = Record< string, any >, RouteId extends string | null = string | 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!' }; } } ```

## 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 `` values to be reset after a successful submission. * @param invalidateAll Set `invalidateAll: false` if you don't want the action to call `invalidateAll` after submission. */ update(options?: { reset?: boolean; invalidateAll?: boolean; }): Promise; }) => void) >; ```

## 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'; ```

## 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'; ```