@sveltejs/kit

import {
	VERSION(alias) const VERSION: string
import VERSIONreference,
	error(alias) function error(status: {
    status: number;
    message: string;
} extends App.Error ? number : never, message?: string | undefined): never (+2 overloads)
import 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; the error will be passed to handleError as an expected error.
Make sure you're not catching the thrown error, which would prevent SvelteKit from handling it.
status 
The HTTP status code. Must be in the range 400-599.
message 
The error message.
{import('./public.js').HttpError} This error instructs SvelteKit to initiate HTTP error handling.
{Error} If the provided status is invalid (not between 400 and 599).
reference,
	fail(alias) function fail(status: number): ActionFailure<undefined> (+1 overload)
import fail
Create an ActionFailure object. Call when form submission fails.
status 
The HTTP status code. Must be in the range 400-599.
reference,
	invalid(alias) function invalid(...issues: (StandardSchemaV1<Input = unknown, Output = Input>.Issue | string)[]): never
import invalid
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.
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');
    }

    // ...
  }
);
2.47.3
reference,
	isActionFailure(alias) function isActionFailure(e: unknown): e is ActionFailure
import isActionFailure
Checks whether this is an action failure thrown by 
{@link 
fail
}
.
e 
The object to check.
reference,
	isHttpError(alias) function isHttpError<T extends number>(e: unknown, status?: T): e is (HttpError & {
    status: T extends undefined ? never : T;
})
import isHttpError
Checks whether this is an error thrown by 
{@link 
error
}
.
status 
The status to filter for.
reference,
	isRedirect(alias) function isRedirect(e: unknown): e is Redirect
import isRedirect
Checks whether this is a redirect thrown by 
{@link 
redirect
}
.
e 
The object to check.
reference,
	isValidationError(alias) function isValidationError(e: unknown): e is ValidationError
import isValidationError
Checks whether this is a validation error thrown by 
{@link 
invalid
}
.
e 
The object to check.
2.47.3
reference,
	json(alias) function json(data: any, init?: ResponseInit): Response
import json
Create a JSON Response object from the supplied data.
data 
The value that will be serialized as JSON.
init 
Options such as status and headers that will be added to the response. Content-Type: application/json and Content-Length headers will be added automatically.
use Response.json
reference,
	normalizeUrl(alias) function normalizeUrl(url: URL | string): {
    url: URL;
    wasNormalized: boolean;
    denormalize: (url?: string | URL) => URL;
}
import normalizeUrl
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.
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
2.18.0
reference,
	redirect(alias) function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL, options?: {
    external?: boolean | string[];
}): never
import 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
status 
The HTTP status code. Must be in the range 300-308.
location 
The location to redirect to.
options 
To redirect to an external URL, you must pass { external: true } to allow any external URL except javascript: URLs, or { external: [...] } with an allowlist of permitted origins.
{import('./public.js').Redirect} This error instructs SvelteKit to redirect to the specified location.
{Error} If the provided status is invalid, the location cannot be used as a header value, or the location is an external URL without permission.
reference,
	text(alias) function text(body: string, init?: ResponseInit): Response
import text
Create a Response object from the supplied body.
body 
The value that will be used as-is.
init 
Options such as status and headers that will be added to the response. A Content-Length header will be added automatically.
use new Response
reference
} from '@sveltejs/kit';

import { invalid(alias) function invalid(...issues: (StandardSchemaV1<Input = unknown, Output = Input>.Issue | string)[]): never
import invalid
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.
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');
    }

    // ...
  }
);
2.47.3
reference } from '@sveltejs/kit';
import { form(alias) function form<Output>(fn: () => MaybePromise<Output>): RemoteForm<void, Output> (+2 overloads)
import form
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
2.27
reference } from '$app/server';
import { tryLoginimport tryLogin } from '#lib/server/auth';
import * as vimport v from 'valibot';

export const loginconst login: RemoteForm<{
    name: string;
    _password: string;
}, void> = form(alias) form<v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly _password: v.StringSchema<undefined>;
}, undefined>, void>(validate: v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly _password: v.StringSchema<undefined>;
}, undefined>, fn: (data: {
    name: string;
    _password: string;
}, issue: {
    name: (message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue;
    _password: (message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue;
} & ((message: string) => StandardSchemaV1<Input = unknown, Output = Input>.Issue)) => MaybePromise<...>): RemoteForm<...> (+2 overloads)
import form
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
2.27
reference(
	vimport v.object(alias) object<{
    readonly name: v.StringSchema<undefined>;
    readonly _password: v.StringSchema<undefined>;
}>(entries: {
    readonly name: v.StringSchema<undefined>;
    readonly _password: v.StringSchema<undefined>;
}): v.ObjectSchema<{
    readonly name: v.StringSchema<undefined>;
    readonly _password: v.StringSchema<undefined>;
}, undefined> (+1 overload)
export object
Creates an object schema.
Hint: This schema removes unknown entries. The output will only include the
entries you specify. To include unknown entries, use looseObject. To
return an issue for unknown entries, use strictObject. To include and
validate unknown entries, use objectWithRest.
entries 
The entries schema.
An object schema.
({ name(property) name: v.StringSchema<undefined>: vimport v.string(alias) string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
A string schema.
(), _password(property) _password: v.StringSchema<undefined>: vimport v.string(alias) string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
A string schema.
() }),
	async ({ name(parameter) name: string, _password(parameter) _password: string }) => {
		const successconst success: any = tryLoginimport tryLogin(name(parameter) name: string, _password(parameter) _password: string);
		if (!successconst success: any) {
			invalid(alias) invalid(...issues: (StandardSchemaV1<Input = unknown, Output = Input>.Issue | string)[]): never
import invalid
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.
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');
    }

    // ...
  }
);
2.47.3
reference('Incorrect username or password');
		}
		// ...	}
);

import { normalizeUrl(alias) function normalizeUrl(url: URL | string): {
    url: URL;
    wasNormalized: boolean;
    denormalize: (url?: string | URL) => URL;
}
import normalizeUrl
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.
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
2.18.0
reference } from '@sveltejs/kit';

const { urlconst url: URL, denormalizeconst denormalize: (url?: string | URL) => URL } = normalizeUrl(alias) normalizeUrl(url: URL | string): {
    url: URL;
    wasNormalized: boolean;
    denormalize: (url?: string | URL) => URL;
}
import normalizeUrl
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.
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
2.18.0
reference('/blog/post/__data.json');
consolenamespace console
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
source
.log(method) Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
v0.1.100
(urlconst url: URL.pathname(property) URL.pathname: string
The pathname property of the URL interface represents a location in a hierarchical structure. It is a string constructed from a list of path segments, each of which is prefixed by a / character.
MDN Reference
); // /blog/post
consolenamespace console
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
source
.log(method) Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
v0.1.100
(denormalizeconst denormalize: (url?: string | URL) => URL('/blog/post/a')); // /blog/post/a/__data.json