```js // @noErrors import { Server, VERSION, defineParams, error, fail, invalid, isActionFailure, isHttpError, isRedirect, isValidationError, 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; ```
## defineParams Define [parameter matchers](/docs/kit/advanced-routing#Matching) for your app.
```dts function defineParams< T extends Record >(definitions: T): DefinedParams; ```
## 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: { status: number; message: string; } extends App.Error ? number : never, message?: string | undefined ): never; ```
```dts function error( status: number, message: string, properties: { status: number; message: string; } extends App.Error ? never : Omit ): never; ```
```dts function error( status: number, properties: Omit & { status?: App.Error['status']; } ): 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; ```
## invalid
Available since 2.47.3
Use this to throw a validation error to imperatively fail form validation. Can be used in combination with `issue` passed to form actions to create field-specific issues. ```ts import { invalid } from '@sveltejs/kit'; import { form } from '$app/server'; import { tryLogin } from '#lib/server/auth'; import * as v from 'valibot'; export const login = form( v.object({ name: v.string(), _password: v.string() }), async ({ name, _password }) => { const success = tryLogin(name, _password); if (!success) { invalid('Incorrect username or password'); } // ... } ); ```
```dts function invalid( ...issues: (StandardSchemaV1.Issue | string)[] ): never; ```
## 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 & { status: T extends undefined ? never : T; }; ```
## isRedirect Checks whether this is a redirect thrown by `redirect`.
```dts function isRedirect(e: unknown): e is Redirect; ```
## isValidationError
Available since 2.47.3
Checks whether this is an validation error thrown by `invalid`.
```dts function isValidationError(e: unknown): e is ActionFailure; ```
## json
use `Response.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, options?: { external?: boolean | string[]; } ): never; ```
## text
use `new Response`
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: App.Error }; ```
## 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: Record; route: { id: string } }) => boolean; ```
- `details.config` The merged adapter-specific route config exported from the route with `export const 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.
```dts vite?: {/*…*/} ```
```dts plugins?: Plugin[]; ```
- available since v3.0.0
Plugins provided by the adapter are placed before any of SvelteKit's own plugins.
## AfterNavigate The argument passed to [`afterNavigate`](/docs/kit/$app-navigation#afterNavigate) callbacks.
```dts type AfterNavigate = (Navigation | NavigationEnter) & { 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; ```
- deprecated Use `fs.rmSync(dir, { force: true, recursive: true })` instead
Remove `dir` and all its contents.
```dts mkdirp: (dir: string) => void; ```
- deprecated Use `fs.mkdirSync(dir, { recursive: true })` instead
Create `dir` and any required parent directories.
```dts config: ValidatedConfig; ```
The fully resolved SvelteKit 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 removed in 3.0. 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 public environment variables as `$app/env/public` if the app uses it.
```dts generateManifest: (opts: { relativePath: string; routes?: RouteDefinition[] }) => string; ```
- `opts.relativePath` A relative path to the base directory of the server build output
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 - returns an array of the files in `directory` that were 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#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').ParseOptions) => string | undefined; ```
- `name` the name of the cookie - `opts` the options, passed directly to `cookie.parseCookie`. See documentation [here](https://github.com/jshttp/cookie?tab=readme-ov-file#cookieparsecookiestr-options)
Gets a cookie that was previously set with `cookies.set`, or from the request headers.
```dts getAll: (opts?: import('cookie').ParseOptions) => Array<{ name: string; value: string }>; ```
- `opts` the options, passed directly to `cookie.parseCookie`. See documentation [here](https://github.com/jshttp/cookie?tab=readme-ov-file#cookieparsecookiestr-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').SerializeOptions) => void; ```
- `name` the name of the cookie - `value` the cookie value - `opts` the options passed to `cookie.stringifySetCookie` with the SvelteKit defaults described above. See documentation [here](https://github.com/jshttp/cookie?tab=readme-ov-file#cookiestringifysetcookiesetcookieobj-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` is `true` by default, as is `secure`, except during development, when it defaults to `false`. These must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `path` option is `'/'` by default. 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').SerializeOptions) => void; ```
- `name` the name of the cookie - `opts` the options passed to `cookie.stringifySetCookie` with the SvelteKit defaults described above. See documentation [here](https://github.com/jshttp/cookie?tab=readme-ov-file#cookiestringifysetcookiesetcookieobj-options)
Deletes a cookie by setting its value to an empty string and setting the expiry date in the past. The `httpOnly` is `true` by default, as is `secure`, except during development, when it defaults to `false`. These must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `path` option is `'/'` by default. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children.
```dts parse: typeof import('cookie').parseSetCookie; ```
Parses a single `Set-Cookie` header. This allows you to apply cookies received from an external source: ```js // @errors: 7031 import { getRequestEvent } from '$app/server'; export async function GET() { const { cookies } = getRequestEvent(); const response = await fetch('...'); for (const str of response.headers.getSetCookie()) { const { name, value, ...options } = cookies.parse(str); cookies.set(name, value, { ...options, path: '/' }); } // ... } ``` Note the use of `headers.getSetCookie()`, which returns an array of cookie headers, _not_ `headers.get('set-cookie')` which returns a single comma-separated string.
```dts serialize: (name: string, value: string, opts: import('cookie').SerializeOptions) => string; ```
- `name` the name of the cookie - `value` the cookie value - `opts` the options passed to `cookie.stringifySetCookie` with the SvelteKit defaults described above. See documentation [here](https://github.com/jshttp/cookie?tab=readme-ov-file#cookiestringifysetcookiesetcookieobj-options)
Serialize a cookie name-value pair into a `Set-Cookie` header string, but don't apply it to the response. The `httpOnly` is `true` by default, as is `secure`, except during development, when it defaults to `false`. These must be explicitly disabled if you want cookies to be readable by client-side JavaScript and/or transmitted over HTTP. The `path` option is `'/'` by default. You can use relative paths, or set `path: ''` to make the cookie only available on the current path and its children.
## DefinedEnvVars The return type of [`defineEnvVars`](/docs/kit/@sveltejs-kit-env#defineEnvVars).
```dts type DefinedEnvVars< T extends Record> > = { readonly [K in keyof T]: EnvVarEntry; }; ```
## DefinedParams The return type of [`defineParams`](/docs/kit/@sveltejs-kit#defineParams).
```dts type DefinedParams< T extends Record > = { readonly [K in keyof T]: ParamEntry; }; ```
## 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
## EnvVarConfig [Environment variables](/docs/kit/environment-variables) can be configured by exporting a `variables` object from `src/env.ts`, using [`defineEnvVars`](/docs/kit/@sveltejs-kit-env#defineEnvVars).
```dts interface EnvVarConfig {/*…*/} ```
```dts public?: boolean; ```
- default `false`
Whether the environment variable can be accessed by client-side code. - if `true`, it can be imported from `$app/env/public` - if `false`, it can be imported from `$app/env/private`, which is a [server-only module](/docs/kit/server-only-modules)
```dts static?: boolean; ```
- default `false`
Whether the value is determined at build time or when the app runs. - if `true`, the build time value is inlined into the bundle. This enables optimisations like dead-code elimination - if `false`, the value is read from the environment when the app starts
```dts schema?: StandardSchemaV1 | ((value: string | undefined) => T | undefined); ```
A [Standard Schema](https://standardschema.dev/) validator that is applied to the value when the app starts. Alternatively, a function that returns the (possibly transformed) value, or throws an error explaining the problem. Returning `undefined` is valid, so a function can describe an optional variable. The validator can output any value — not necessarily a string — but public, non-static values must be serializable by [devalue](https://github.com/sveltejs/devalue) so that they can be sent to the browser. If omitted, the value must be set, but may be an empty string.
```dts description?: string; ```
A description of the variable that will be used for inline documentation on hover.
## GotoOptions
```dts interface GotoOptions {/*…*/} ```
```dts replace?: boolean; ```
- default `false`
If `true`, replaces the current history entry rather than creating a new one.
```dts replaceState?: boolean; ```
- deprecated Use `replace` instead.
```dts shallow?: boolean; ```
- default `false`
If `true`, updates the URL and `page.state` without navigating.
```dts reset?: boolean; ```
- default `true, or false when `shallow` is true`
If `true`, resets the scroll position (to the top of the page, or to the element matching the URL's `#hash` if there is one) and resets focus (to the ``, or the `autofocus` element if there is one) once the navigation completes. If `false`, the current scroll position and focused element are left alone.
```dts refreshAll?: boolean; ```
- default `false`
If `true`, reruns all `load` functions and queries of the page.
```dts invalidate?: Array boolean)>; ```
Causes any `load` functions to rerun if they depend on one of the URLs.
```dts invalidateAll?: boolean; ```
- deprecated Use `refreshAll` instead.
```dts state?: App.PageState; ```
An optional object that will be available as `page.state`.
```dts persistState?: boolean; ```
- default `false`
If `true`, `page.state` will be restored after a full page reload.
## Handle The [`handle`](/docs/kit/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 ) => Promise; }) => MaybePromise; ```
## HandleClientError The client-side [`handleError`](/docs/kit/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. The returned object can include a `status` property to override the HTTP status code used in the response. If omitted, the status defaults to 500.
```dts type HandleClientError = (input: { error: unknown; event: NavigationEvent; status: number; message: string; }) => MaybePromise; ```
## HandleFetch The [`handleFetch`](/docs/kit/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#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. The returned object can include a `status` property to override the HTTP status code used in the response. If omitted, the status defaults to 500.
```dts type HandleServerError = (input: { error: unknown; event: RequestEvent; status: number; message: string; }) => MaybePromise; ```
## HandleValidationError The [`handleValidationError`](/docs/kit/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.
## InvalidField A function and proxy object used to imperatively create validation errors in form handlers. Access properties to create field-specific issues: `issue.fieldName('message')`. The type structure mirrors the input data structure for type-safe field access. Call `invalid(issue.foo(...), issue.nested.bar(...))` to throw a validation error.
```dts type InvalidField = WillRecurseIndefinitely extends true ? Record : NonNullable extends | string | number | boolean | File ? (message: string) => StandardSchemaV1.Issue : NonNullable extends Array ? { [K in number]: InvalidField; } & ((message: string) => StandardSchemaV1.Issue) : NonNullable extends RemoteFormInput ? { [K in keyof T]-?: InvalidField; } & (( message: string ) => StandardSchemaV1.Issue) : Record; ```
## KitConfig See the [configuration reference](/docs/kit/configuration) for details. ## LiveQueryRequestedResult
```dts type LiveQueryRequestedResult = Iterable< LiveRequestedEntry > & AsyncIterable> & { /** * Call `reconnect` on all live queries selected by this `requested` invocation. * This is identical to: * ```ts * import { requested } from '$app/server'; * * for await (const { query } of requested(liveQuery, ...)) { * void query.reconnect(); * } * ``` */ reconnectAll: () => Promise; }; ```
## LiveRequestedEntry A single entry yielded by [`requested`](/docs/kit/$app-server#requested) when called with a `query.live`. `arg` is the validated argument; `query` is a `RemoteLiveQuery` bound to the client's original cache key, so `reconnect()` targets the correct client subscription.
```dts type LiveRequestedEntry = { arg: Validated; query: RemoteLiveQuery; }; ```
## 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 | 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#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; ```
## MatcherParam Extracts the param type from a matcher.
```dts type MatcherParam> = M extends StandardSchemaV1 ? Inner extends ParamValue ? Inner : Inner extends StandardSchemaV1 ? StandardSchemaV1.InferOutput extends ParamValue ? StandardSchemaV1.InferOutput : never : never : never; ```
## Navigation
```dts type Navigation = | NavigationExternal | NavigationFormSubmit | NavigationPopState | NavigationLink; ```
## NavigationBase
```dts interface NavigationBase {/*…*/} ```
```dts type: NavigationType; ```
The type of navigation: - `enter`: The app has hydrated/started - `form`: The user submitted a `` - `goto`: Navigation was triggered by a `goto(...)` call or a redirect - `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 - `popstate`: Navigation was triggered by back/forward navigation
```dts shallow: boolean; ```
Whether this is a shallow navigation.
```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 The navigation that occurs when the app starts/hydrates
```dts interface NavigationEnter extends NavigationBase {/*…*/} ```
```dts type: 'enter'; ```
```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 occurred 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 type NavigationExternal = NavigationGoto | NavigationLeave; ```
## NavigationFormSubmit A navigation triggered by a ``
```dts interface NavigationFormSubmit extends NavigationBase {/*…*/} ```
```dts type: 'form'; ```
```dts event: SubmitEvent; ```
The `SubmitEvent` that caused the navigation
## NavigationGoto A navigation triggered by a `goto(...)` call or a redirect
```dts interface NavigationGoto extends NavigationBase {/*…*/} ```
```dts type: 'goto'; ```
## NavigationLeave A navigation triggered by the tab being closed, or the user navigating to a different document
```dts interface NavigationLeave extends NavigationBase {/*…*/} ```
```dts type: 'leave'; ```
## NavigationLink A navigation triggered by a link click
```dts interface NavigationLink extends NavigationBase {/*…*/} ```
```dts type: 'link'; ```
```dts event: PointerEvent; ```
The `PointerEvent` that caused the navigation
## NavigationPopState A navigation triggered by back/forward navigation
```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
```dts scroll: { x: number; y: number } | null; ```
The scroll position associated with this navigation. For the `from` target, this is the scroll position at the moment of navigation. For the `to` target, this represents the scroll position that will be or was restored: - In `beforeNavigate` and `onNavigate`, this is only available for `popstate` navigations (back/forward button) and will be `null` for other navigation types, since the final scroll position isn't known ahead of time. - In `afterNavigate`, this is always the scroll position that was applied after the navigation completed.
## NavigationType - `enter`: The app has hydrated/started - `form`: The user submitted a `` - `goto`: Navigation was triggered by a `goto(...)` call or a redirect - `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 - `popstate`: Navigation was triggered by back/forward navigation
```dts type NavigationType = | 'enter' | 'form' | 'leave' | 'link' | 'goto' | 'popstate'; ```
## OnNavigate The argument passed to [`onNavigate`](/docs/kit/$app-navigation#onNavigate) callbacks.
```dts type OnNavigate = 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.
```dts interface Page< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```
```dts url: ReadonlyURL & { readonly pathname: ResolvedPathname | (string & {}) }; ```
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 [`goto`](/docs/kit/$app-navigation#goto) from `$app/navigation`.
```dts shallow: { /** Parameters of the target route, or `null` if the URL does not resolve to a route. */ params: AppLayoutParams<'/'> | null; /** Info about the target route, or `null` if the URL does not resolve to a route. */ route: { id: AppRouteId } | null; /** The normalized URL passed to `goto(..., { shallow: true })`. */ url: ReadonlyURL; } | null; ```
Information about the target of the current shallow navigation, or `null` if no shallow navigation has occurred.
```dts form: any; ```
Filled only after a form submission. See [form actions](/docs/kit/form-actions) for more info.
## ParamDefinition A param matcher definition passed to [`defineParams`](/docs/kit/@sveltejs-kit#defineParams).
```dts type ParamDefinition = | ((param: string) => ParamValue | undefined) | StandardSchemaV1; ```
## ParamMatcher The shape of a param matcher. See [matching](/docs/kit/advanced-routing#Matching) for more info.
```dts type ParamMatcher = StandardSchemaV1< string, Output >; ```
## ParamValue A value that can be parsed from a URL param and losslessly encoded with `String(...)`.
```dts type ParamValue = string | number | boolean | bigint; ```
## PrerenderOption
```dts type PrerenderOption = boolean | 'auto'; ```
## QueryRequestedResult
```dts type QueryRequestedResult = Iterable< RequestedEntry > & AsyncIterable> & { /** * Call `refresh` on all queries selected by this `requested` invocation. * This is identical to: * ```ts * import { requested } from '$app/server'; * * for await (const { query } of requested(getPost, ...)) { * void query.refresh(); * } * ``` */ refreshAll: () => Promise; }; ```
## ReadonlyURL
```dts type ReadonlyURL = Readonly< Omit & { searchParams: ReadonlyURLSearchParams; } >; ```
## ReadonlyURLSearchParams
```dts type ReadonlyURLSearchParams = Omit< URLSearchParams, 'set' | 'append' | 'delete' | 'sort' >; ```
## 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 type of a remote `command` function. See [Remote functions](/docs/kit/remote-functions#command) for full documentation.
```dts type RemoteCommand = { ( arg: undefined extends Input ? Input | void : Input ): Promise & { updates( ...updates: RemoteQueryUpdate[] ): Promise; }; /** The number of pending command executions */ get pending(): number; }; ```
## RemoteForm The type 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; /** The `` element this instance is currently attached to, if any. */ get element(): HTMLFormElement | null; /** Submit the currently attached form programmatically. */ submit(): Promise & { updates: ( ...updates: RemoteQueryUpdate[] ) => Promise; }; /** Use the `enhance` method to influence what happens when the form is submitted. */ enhance( callback: RemoteFormEnhanceCallback ): { 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 yet been * edited and blurred. This option is ignored for forms that have previously been * submitted, in which case all fields are always subject to validation * (unless the form is reset, at which point it is treated as pristine) */ all?: boolean; /** Set this to `true` to only run the `preflight` validation. */ preflightOnly?: boolean; }): Promise; /** The result of the form submission */ get result(): Output | undefined; /** The number of pending submissions */ get pending(): number; /** True if the form has been submitted at least once, and hasn't been reset since */ get submitted(): boolean; /** Access form fields using object notation */ fields: RemoteFormFieldsRoot; }; ```
## RemoteFormEnhanceCallback The callback passed to a remote form's `enhance` method. See [Remote functions](/docs/kit/remote-functions#form) for full documentation.
```dts type RemoteFormEnhanceCallback< Input extends RemoteFormInput | void = RemoteFormInput | void, Output = any > = ( form: RemoteFormEnhanceInstance ) => MaybePromise; ```
## RemoteFormEnhanceInstance The form instance as received inside an `enhance` callback. See [Remote functions](/docs/kit/remote-functions#form) for full documentation.
```dts type RemoteFormEnhanceInstance< Input extends RemoteFormInput | void = RemoteFormInput | void, Output = any > = Omit< RemoteForm, 'enhance' | 'element' > & { readonly element: HTMLFormElement; }; ```
## 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
```dts type RemoteFormFieldValue = | string | string[] | number | boolean | File | File[]; ```
## 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> : // [NonNullable] is used to prevent distributing over union while still allowing // nullable wrappers (e.g. `string[] | undefined` from a schema with `.default([])`) // to be treated as arrays; only the last condition should distribute over unions [NonNullable] extends [string[] | File[]] ? RemoteFormField> & { [K in number]: RemoteFormField< NonNullable[number] >; } : [NonNullable] extends [Array] ? RemoteFormFieldContainer> & { [K in number]: RemoteFormFields; } : RemoteFormFieldContainer & { [K in KeysOfUnion]-?: RemoteFormFields< ValueOfUnionKey >; }; ```
## RemoteFormInput
```dts interface RemoteFormInput {/*…*/} ```
```dts [key: string]: MaybeArray | undefined; ```
## RemoteFormIssue
```dts interface RemoteFormIssue {/*…*/} ```
```dts message: string; ```
```dts path: Array; ```
## RemoteLiveQuery
```dts type RemoteLiveQuery = RemoteResource & AsyncIterable & { /** `true` if the live stream is currently connected. */ readonly connected: boolean; /** `true` once the current live stream iterator is done. */ readonly done: boolean; /** Reconnects the live stream immediately. */ reconnect(): Promise; }; ```
## RemoteLiveQueryFunction The type of a remote `query.live` function. See [Remote functions](/docs/kit/remote-functions#query.live) for full documentation. The optional `Validated` generic parameter represents the argument type *after* the query's schema has validated and (optionally) transformed it, and matches the type yielded by [`requested`](/docs/kit/$app-server#requested).
```dts type RemoteLiveQueryFunction< Input, Output, _Validated = Input > = ( arg: undefined extends Input ? Input | void : Input ) => RemoteLiveQuery; ```
## RemotePrerenderFunction The type of a remote `prerender` function. See [Remote functions](/docs/kit/remote-functions#prerender) for full documentation.
```dts type RemotePrerenderFunction = ( arg: undefined extends Input ? Input | void : 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 a query's value during a [single-flight mutation](https://svelte.dev/docs/kit/remote-functions#Single-flight-mutations) to provide optimistic updates. * * ```svelte * * *
{ * await form.submit().updates( * todos.withOverride((todos) => [...todos, { text: form.fields.text.value() }]) * ); * })}> * * *
* ``` */ withOverride( update: (current: T) => T ): RemoteQueryOverride; }; ```
## RemoteQueryFunction The return value of a remote `query` function. See [Remote functions](/docs/kit/remote-functions#query) for full documentation. The optional `Validated` generic parameter represents the argument type *after* the query's schema has validated and (optionally) transformed it — this is the type the query's implementation function receives on the server, and the type yielded by [`requested`](/docs/kit/$app-server#requested). For queries declared with [Standard Schema](https://standardschema.dev/) it differs from `Input` when the schema contains a transform (e.g. `v.pipe(v.number(), v.transform(String))` has `Input = number` but `Validated = string`). For `'unchecked'` validators and queries without arguments it defaults to `Input`.
```dts type RemoteQueryFunction< Input, Output, _Validated = Input > = ( arg: undefined extends Input ? Input | void : Input ) => RemoteQuery; ```
## RemoteQueryOverride
```dts type RemoteQueryOverride = () => void; ```
## RemoteQueryUpdate
```dts type RemoteQueryUpdate = | RemoteQuery | RemoteLiveQuery | RemoteQueryFunction | RemoteLiveQueryFunction | RemoteQueryOverride; ```
## RemoteResource
```dts type RemoteResource = Promise & { /** The error in case the query fails. */ get error(): App.Error | undefined; /** `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(): T; ready: true; } ); ```
## RequestEvent
```dts interface RequestEvent< Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null > {/*…*/} ```
```dts readonly cookies: Cookies; ```
Get or set cookies related to the current request
```dts readonly 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#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 readonly getClientAddress: () => string; ```
The client's IP address, set by the adapter.
```dts readonly locals: App.Locals; ```
Contains custom data that was added to the request within the [`server handle hook`](/docs/kit/hooks#handle).
```dts readonly params: Params; ```
The parameters of the current route - e.g. for a route like `/blog/[slug]`, a `{ slug: string }` object. Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error. Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
```dts readonly platform: Readonly | undefined; ```
Additional data made available through the adapter.
```dts readonly request: Request; ```
The original request object.
```dts readonly 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. Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error. Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
```dts readonly 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 instead.
```dts readonly url: URL; ```
The requested URL. Inside `query` functions (including `query.batch` and `query.live`), accessing this property throws an error. Pass values from the page as arguments to the query instead. Inside `form` and `command` functions it relates to the page the remote function was called from, _not_ the URL of the endpoint SvelteKit creates for the remote function. Never use it to determine whether or not a user is authorized to access certain data, as these values are part of the request which could be manipulated.
```dts readonly 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 readonly 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 readonly 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 readonly 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; ```
## RequestedEntry A single entry yielded by [`requested`](/docs/kit/$app-server#requested) when called with a regular `query`. `arg` is the validated argument (the input *after* the query's schema validated and transformed it, if applicable); `query` is a `RemoteQuery` bound to the client's original cache key, so `refresh()` / `set()` will update the correct client entry.
```dts type RequestedEntry = { arg: Validated; query: RemoteQuery; }; ```
## RequestedResult
```dts type RequestedResult = | QueryRequestedResult | LiveQueryRequestedResult; ```
## Reroute
Available since 2.3.0
The [`reroute`](/docs/kit/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 which files should be preloaded. Files are preloaded via `` tags added to the `` tag; if `output.linkHeaderPreload` is enabled, dynamically rendered pages use the [`Link` response header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link) instead. 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 Information required to instantiate a new `Server` instance.
```dts interface SSRManifest {/*…*/} ```
```dts appDir: string; ```
The directory where SvelteKit keeps its stuff, including static assets (such as JS and CSS) and internally-used routes.
```dts appPath: string; ```
The `base` and `appDir` settings combined without a leading slash.
```dts assets: Set; ```
Static files from `config.files.assets` and the service worker (if any).
```dts mimeTypes: Record; ```
## ServerInit
Available since 2.10.0
The [`init`](/docs/kit/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; ```
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.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 `
` 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; }) => MaybePromise) >; ```
## Transport
Available since 2.11.0
The [`transport`](/docs/kit/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#transport) hook.
```dts interface Transporter< T = any, U = any /* minus falsy values, but we can't properly express that */ > {/*…*/} ```
```dts encode: (value: T) => false | U; ```
```dts decode: (data: U) => T; ```
## ValidationError A validation error thrown by `invalid`.
```dts interface ValidationError {/*…*/} ```
```dts issues: StandardSchemaV1.Issue[]; ```
The validation issues
## 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' | 'unsafe-allow-redirects' | 'unsafe-webtransport-hashes' | 'wasm-unsafe-eval' | 'trusted-types-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:' | 'ws:' | 'wss:' | 'data:' | 'mediastream:' | 'blob:' | 'filesystem:' | (`${string}:` & {}); 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 sandbox?: Array< | 'allow-downloads-without-user-activation' | 'allow-forms' | 'allow-modals' | 'allow-orientation-lock' | 'allow-pointer-lock' | 'allow-popups' | 'allow-popups-to-escape-sandbox' | 'allow-presentation' | 'allow-same-origin' | 'allow-scripts' | 'allow-storage-access-by-user-activation' | 'allow-top-navigation' | 'allow-top-navigation-by-user-activation' >; ```
```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
```dts referrer?: Array< | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url' | 'none' >; ```
- deprecated
## DeepPartial
```dts type DeepPartial = T extends | Record | unknown[] ? { [K in keyof T]?: T[K] extends | Record | unknown[] ? DeepPartial : T[K]; } : T | undefined; ```
## HasNonOptionalBoolean
```dts type HasNonOptionalBoolean = IsAny extends true ? never : [T] extends [boolean] ? true : T extends Array ? HasNonOptionalBoolean : T extends Record ? { [K in keyof T]: HasNonOptionalBoolean; }[keyof T] : never; ```
## HttpMethod
```dts type HttpMethod = | 'GET' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS'; ```
## IsAny
```dts type IsAny = 0 extends 1 & T ? true : false; ```
## Logger
```dts interface Logger {/*…*/} ```
```dts (msg: string): void; ```
```dts success(msg: string): void; ```
```dts error(msg: string): void; ```
Print a bold red message to stderr
```dts warn(msg: string): void; ```
Print a bold yellow message to stderr
```dts minor(msg: string): void; ```
Print faded text to stdout if `verbose === true`
```dts info(msg: string): void; ```
Print to stdout if `verbose === true`
```dts err(msg: string): void; ```
Print to stderr without formatting
```dts prettyError(error: unknown, caller?: string): void; ```
Print a bold red message, followed by a stack trace for each error (following `.cause` chains)
## 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; ```
## PrerenderInvalidUrlHandler
```dts interface PrerenderInvalidUrlHandler {/*…*/} ```
```dts (details: { href: string; referrer: string | null; message: string }): void; ```
## PrerenderInvalidUrlHandlerValue
```dts type PrerenderInvalidUrlHandlerValue = | 'fail' | 'warn' | 'ignore' | PrerenderInvalidUrlHandler; ```
## 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'; ```