@sveltejs/kit

import {
	class Server
referenceServer,
	const VERSION: string
referenceVERSION,
	
function error(status: {
    status: number;
    message: string;
} extends App.Error ? number : never, message?: string | undefined): never (+2 overloads)
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.
@param
status The HTTP status code. Must be in the range 400-599.
@param
message The error message.
@throws
import('./public.js').HttpError This error instructs SvelteKit to initiate HTTP error handling.
@throws
Error If the provided status is invalid (not between 400 and 599).
referenceerror,
	function fail(status: number): ActionFailure<undefined> (+1 overload)
Create an ActionFailure object. Call when form submission fails.
@param
status The HTTP status code. Must be in the range 400-599.
referencefail,
	function invalid(...issues: (StandardSchemaV1<Input = unknown, Output = Input>.Issue | string)[]): never
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.
@example
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');
	}

	// ...
  }
);
@since
2.47.3
referenceinvalid,
	function isActionFailure(e: unknown): e is ActionFailure
Checks whether this is an action failure thrown by 
{@link 
fail
}
.
@param
e The object to check.
referenceisActionFailure,
	
function isHttpError<T extends number>(e: unknown, status?: T): e is (HttpError & {
    status: T extends undefined ? never : T;
})
Checks whether this is an error thrown by 
{@link 
error
}
.
@param
status The status to filter for.
referenceisHttpError,
	function isRedirect(e: unknown): e is Redirect
Checks whether this is a redirect thrown by 
{@link 
redirect
}
.
@param
e The object to check.
referenceisRedirect,
	function isValidationError(e: unknown): e is import("$app/server").ValidationError
Checks whether this is an validation error thrown by 
{@link 
invalid
}
.
@param
e The object to check.
@since
2.47.3
referenceisValidationError,
	function json(data: any, init?: ResponseInit): Response
Create a JSON Response object from the supplied data.
@param
data The value that will be serialized as JSON.
@param
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.
@deprecated
use Response.json
referencejson,
	
function normalizeUrl(url: URL | string): {
    url: URL;
    wasNormalized: boolean;
    denormalize: (url?: string | URL) => URL;
}
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
@since
2.18.0
referencenormalizeUrl,
	
function redirect(status: 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | ({} & number), location: string | URL, options?: {
    external?: boolean | string[];
}): never
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
@param
status The HTTP status code. Must be in the range 300-308.
@param
location The location to redirect to.
@param
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.
@throws
import('./public.js').Redirect This error instructs SvelteKit to redirect to the specified location.
@throws
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.
referenceredirect,
	function text(body: string, init?: ResponseInit): Response
Create a Response object from the supplied body.
@param
body The value that will be used as-is.
@param
init Options such as status and headers that will be added to the response. A Content-Length header will be added automatically.
@deprecated
use new Response
referencetext
} from '@sveltejs/kit';

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

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

export const 
const login: RemoteForm<{
    name: string;
    _password: string;
}, void>login = 
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)
Creates a form object that can be spread onto a <form> element.
See Remote functions for full documentation.
@since
2.27
referenceform(
	import vv.
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.
@param
entries The entries schema.
@returns
An object schema.object({ name: v.StringSchema<undefined>name: import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returns
A string schema.string(), _password: v.StringSchema<undefined>_password: import vv.
function string(): v.StringSchema<undefined> (+1 overload)
export string
Creates a string schema.
@returns
A string schema.string() }),
	async ({ name: stringname, _password: string_password }) => {
		const const success: anysuccess = import tryLogintryLogin(name: stringname, _password: string_password);
		if (!const success: anysuccess) {
			function invalid(...issues: (StandardSchemaV1<Input = unknown, Output = Input>.Issue | string)[]): never
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.
@example
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');
	}

	// ...
  }
);
@since
2.47.3
referenceinvalid('Incorrect username or password');
		}

		// ...
	}
);

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

const { const url: URLurl, const denormalize: (url?: string | URL) => URLdenormalize } = 
function normalizeUrl(url: URL | string): {
    url: URL;
    wasNormalized: boolean;
    denormalize: (url?: string | URL) => URL;
}
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
@since
2.18.0
referencenormalizeUrl('/blog/post/__data.json');
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
@see
sourceconsole.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.
@since
v0.1.100log(const url: URLurl.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
pathname); // /blog/post
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
@see
sourceconsole.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.
@since
v0.1.100log(const denormalize: (url?: string | URL) => URLdenormalize('/blog/post/a')); // /blog/post/a/__data.json